sycommon-python-lib 0.2.10a5__tar.gz → 0.2.10b7__tar.gz

{sycommon_python_lib-0.2.10a5 → sycommon_python_lib-0.2.10b7}/PKG-INFO

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

{sycommon_python_lib-0.2.10a5 → sycommon_python_lib-0.2.10b7}/pyproject.toml

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

{sycommon_python_lib-0.2.10a5 → sycommon_python_lib-0.2.10b7}/src/sycommon/agent/deep_agent.py

@@ -133,6 +133,52 @@ def _match_summary_prefix_overlap(text: str, summary: str,
     return 0
 
 
+# 🔑 复读尾部熔断（9/9 田甜事故最后一环）：贪心解码锁死后输出退化成
+# 「短单元无脑重复」（实测指令句连抄 1780 次直到 max_tokens）。只查
+# 尾部 —— 重复段在中间而结尾正常是正常文本（引用/排比），交给回显剥离。
+def _detect_repetition_tail(text: str, *, unit_min: int = 6) -> bool:
+    """检测文本尾部是否陷入单元级复读。
+
+    取尾部 window 字符，对长度 >= unit_min 的所有候选单元，若该单元
+    连续重复出现在尾部且重复次数 >= repeat_min 即判定锁死。
+    unit_min=6 让 markdown 表格分隔线（|---|）、常见短语相邻复现不误伤；
+    超短单元（单字/两字词）复读用更小下限单独判定。
+    """
+    if not text or len(text) < 40:
+        return False
+    window = text[-600:]
+    repeat_min = 4
+    # 1) 常规单元：长度 unit_min..64,从长到短,命中即报
+    for size in range(64, unit_min - 1, -1):
+        unit = window[-size:]
+        if unit.count("\n") > size // 2:
+            continue  # 大半是换行的"单元"不可信
+        n = 0
+        i = len(window)
+        while i >= size and window[i - size:i] == unit:
+            n += 1
+            i -= size
+        if n >= repeat_min:
+            return True
+    # 2) 超短单元（2-5 字符）复读：需要更高重复次数（10+）才报,
+    #    避免「的地得」、缩进、表格线等正常高频短串误伤。
+    #    下限取 unit_min（调用方传 unit_min=2 即启用 2 字符判定）。
+    for size in range(5, unit_min - 1, -1):
+        if size < 2:
+            break
+        unit = window[-size:]
+        if unit.strip() == "":
+            continue
+        n = 0
+        i = len(window)
+        while i >= size and window[i - size:i] == unit:
+            n += 1
+            i -= size
+        if n >= 10:
+            return True
+    return False
+
+
 @tool
 def get_current_date() -> str:
     """获取当前日期时间（北京时间）"""
@@ -364,6 +410,9 @@ class DeepAgent:
         # 兜底：累积流式 chunk 中的 usage_metadata（middleware 在流式场景可能拿不到）
         total_input_tokens = 0
         total_output_tokens = 0
+        # 🔑 复读尾部熔断状态：上次判定时的文本长度（100 字符节流）+ 熔断标记
+        _last_repetition_check = 0
+        _repetition_detected = False
 
         # ── 设置 chat turn 级 trace_id ──
         # 如果上层（HTTP 中间件等）已设置 trace_id 则沿用，否则生成新的。
@@ -847,6 +896,21 @@ class DeepAgent:
                             await on_event(event)
                         yield event
 
+                        # 🔑 复读尾部熔断：累积文本尾部陷入单元级复读即中断流,
+                        # 不再继续消费（后面全是复读垃圾,还会烧满 max_tokens）。
+                        # 判定按 100 字符节流,避免每 token 全量比对。
+                        if len(ai_text_content) - _last_repetition_check >= 100:
+                            _last_repetition_check = len(ai_text_content)
+                            if _detect_repetition_tail(ai_text_content):
+                                SYLogger.warning(
+                                    f"[DeepAgent] 复读熔断: 检测到尾部单元级复读,中断本轮流 "
+                                    f"(ai_text_len={len(ai_text_content)}, stream_step={stream_step})")
+                                _repetition_detected = True
+                                break
+                    elif _detect_repetition_tail(ai_text_content) and not _repetition_detected:
+                        # content 为空但此前已判定复读（如续流 chunk）,同样熔断
+                        pass
+
                 elif msg_type == "ToolMessage":
                     if ai_chunk_buffer:
                         SYLogger.debug(
@@ -927,6 +991,37 @@ class DeepAgent:
                 f"stream_step={stream_step} | ai_text_len={len(ai_text_content)} | "
                 f"tool_calls={len(current_tool_calls)}")
 
+            # 🔑 复读熔断收尾：熔断发生时尾部截掉复读垃圾（保留正常前文）,
+            # 追加一个 error 事件提示上层（与空响应同通道,可触发上层降级/重试）。
+            if _repetition_detected:
+                # 熔断发生时尾部截掉复读垃圾:去掉末尾最后一份完整复读单元
+                # (从尾部窗口反推最大重复单元),保留正常前文
+                cleaned_tail = ai_text_content
+                window = ai_text_content[-600:]
+                for size in range(64, 1, -1):
+                    unit = window[-size:]
+                    if size >= 6:
+                        n, i = 0, len(window)
+                        while i >= size and window[i - size:i] == unit:
+                            n += 1
+                            i -= size
+                        if n >= 4:
+                            cleaned_tail = ai_text_content[:-len(unit) * 1].rstrip()
+                            break
+                    elif unit.strip() and window[-(size * 10):] == unit * 10:
+                        cleaned_tail = ai_text_content[:-size].rstrip()
+                        break
+                ai_text_content = cleaned_tail
+                SYLogger.warning(
+                    f"[DeepAgent] 复读熔断生效: 本轮流提前结束,截断前长度 {len(ai_text_content)}")
+                event = ChatEventBuilder.error(
+                    "模型输出陷入重复循环，已自动中断（repetition loop detected）",
+                    code="repetition_loop",
+                )
+                if on_event:
+                    await on_event(event)
+                yield event
+
             # 空响应检测：模型被调用但没有产出任何文本。
             # 🔑 治本修复：纯空响应（无文本且无工具调用，常见于用户派生 key 被网关拒、
             # 网关返回空壳 AIMessage 而非异常）不再静默只打 warning —— 把它翻译成

{sycommon_python_lib-0.2.10a5 → sycommon_python_lib-0.2.10b7}/src/sycommon/agent/middleware/model_request_prep.py

@@ -34,10 +34,55 @@ from langchain.agents.middleware.types import (
     ModelResponse,
     ResponseT,
 )
-from langchain_core.messages import BaseMessage, HumanMessage
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage
 
 from sycommon.logging.kafka_log import SYLogger
 
+# 🔑 回显剥离（9/9 田甜复读事故）：模型把注入的备忘块整块回显进输出，回显随
+# ModelResponse 写入 checkpointer → 下轮上下文里旧回显+新注入并存 → 回显越滚
+# 越多 → 贪心解码锁死成句级复读（实测单条 1780 次）。三层标签成对闭合整块删；
+# 未闭合（复读到 max_tokens 等不到闭合）从开标签截断到结尾 —— 复读垃圾只会
+# 出现在开标签之后，前文正常内容保留。
+_ECHO_TAG_PATTERNS = tuple(re.compile(p, re.DOTALL) for p in (
+    r'<internal_context_data>.*?</internal_context_data>',
+    r'<compressed_history>.*?</compressed_history>',
+    r'<system_context>.*?</system_context>',
+    r'<internal_context_data>(?!.*</internal_context_data>).*',
+    r'<compressed_history>(?!.*</compressed_history>).*',
+    r'<system_context>(?!.*</system_context>).*',
+))
+
+
+def _strip_echo_text(text: str) -> str:
+    """剥掉一段文本里的备忘回显块，返回清洗后文本。"""
+    for pat in _ECHO_TAG_PATTERNS:
+        if pat.search(text):
+            text = pat.sub('', text)
+    return text.strip()
+
+
+def dedupe_memo_lines(summary_text: str) -> str:
+    """备忘条目逐行去重（保持首现顺序与空行）。
+
+    多轮压缩时新备忘把旧备忘 + 历史回显一起总结，重复条目（实测「文件:
+    …」相邻出现两次、「事实: 需求大小分布…」逐轮翻倍）被原样折叠进备忘，
+    备忘自身开始自我复制——注入前去重断掉这一层。
+    """
+    if not summary_text:
+        return summary_text
+    seen: set[str] = set()
+    out: list[str] = []
+    for line in summary_text.splitlines():
+        key = line.strip()
+        if not key:
+            out.append(line)
+            continue
+        if key in seen:
+            continue
+        seen.add(key)
+        out.append(line)
+    return "\n".join(out)
+
 
 class ModelRequestPrepMiddleware(AgentMiddleware):
     """模型请求预处理：摘要重定位 + 动态压 max_tokens。
@@ -59,6 +104,30 @@ class ModelRequestPrepMiddleware(AgentMiddleware):
     def name(self) -> str:
         return "ModelRequestPrepMiddleware"
 
+    def _strip_summary_echo(self, response) -> "ModelResponse[Any]":
+        """响应侧剥回显（断环点）：ModelResponse.result 里每条 AIMessage 的
+        content 先剥回显块再随 checkpoint 持久化 —— 历史里不再躺回显，
+        正反馈环在写入侧断掉。无命中返回原对象（零开销）；多模态 list
+        content 不动（无稳定文本形态，误伤风险大于收益）。
+        """
+        result = getattr(response, "result", None)
+        if not result:
+            return response
+        for msg in result:
+            content = getattr(msg, "content", None)
+            if not isinstance(msg, AIMessage) or not isinstance(content, str):
+                continue
+            cleaned = _strip_echo_text(content)
+            if cleaned != content:
+                try:
+                    msg.content = cleaned
+                    SYLogger.warning(
+                        "[ModelRequestPrep] 已剥除模型输出中的备忘回显 "
+                        f"(len {len(content)} → {len(cleaned)})")
+                except Exception:
+                    pass
+        return response
+
     def _relocate_summaries(
         self, request: ModelRequest[ContextT]
     ) -> ModelRequest[ContextT]:
@@ -84,6 +153,9 @@ class ModelRequestPrepMiddleware(AgentMiddleware):
         if not _summary_text:
             return request
 
+        # 🔑 注入前去重：多轮压缩的叠加重复条目不进 system（见 dedupe_memo_lines）
+        _summary_text = dedupe_memo_lines(_summary_text)
+
         from deepagents.middleware._utils import append_to_system_message
         # 🔑 注入形态 = 备忘在前、行为契约在后（recency：靠近对话末端的指令
         # 遵循度最高），且用正向指令替代"不要复述"禁令 —— 负向禁令对
@@ -148,7 +220,13 @@ class ModelRequestPrepMiddleware(AgentMiddleware):
         request: ModelRequest[ContextT],
         handler: Callable[[ModelRequest[ContextT]], Awaitable[ModelResponse[ResponseT]]],
     ) -> ModelResponse[ResponseT]:
-        """拦截模型调用：先做摘要重定位与 max_tokens 动态压，再交给 handler。"""
+        """拦截模型调用：摘要重定位（注入前去重）→ max_tokens 动态压 →
+        响应剥回显（断环），再返回 handler 结果。"""
         request = self._relocate_summaries(request)
         self._clamp_max_tokens(request)
-        return await handler(request)
+        response = await handler(request)
+        try:
+            return self._strip_summary_echo(response)
+        except Exception as e:
+            SYLogger.warning(f"[ModelRequestPrep] strip echo failed(放行): {e}")
+            return response

{sycommon_python_lib-0.2.10a5 → sycommon_python_lib-0.2.10b7}/src/sycommon/agent/sandbox/minio_sync.py

@@ -892,12 +892,13 @@ class MinioSyncService(metaclass=SingletonMeta):
         替代旧 resp.read() 整文件进内存：大附件场景一批 5 路并发 × 全量驻留
         = 数百 MB~GB 级 RSS 峰值（打爆内存的根因）。流式写盘后内存峰值 ≈ 单块，
         与文件大小无关；与 _sync_one 的 adownload_to_file 落盘模式对称。
+        块大小 1MB（5 路并发 × 1MB = 常驻 ~5MB 级）。
         """
         resp = self._client.get_object(self._bucket, key)
         try:
             total = 0
             with open(dest, "wb") as f:
-                for chunk in resp.stream(5 * 1024 * 1024):
+                for chunk in resp.stream(1 * 1024 * 1024):
                     f.write(chunk)
                     total += len(chunk)
             return total

{sycommon_python_lib-0.2.10a5 → sycommon_python_lib-0.2.10b7}/src/sycommon/auth/ldap_service.py

@@ -70,6 +70,10 @@ class LDAPAuthResult(BaseModel):
     error: Optional[str] = None
 
 
+class LDAPAuthError(Exception):
+    """单台 LDAP 服务器认证失败(连接或绑定),消息交由上层分类。"""
+
+
 class LDAPAuthService:
     """LDAP 认证服务
 
@@ -89,6 +93,9 @@ class LDAPAuthService:
     def __init__(self, config: LDAPConfig):
         self.config = config
         self._connection = None
+        # 记住最近一次成功过的服务器地址:认证成功/搜索成功后直连它,
+        # 失败才重新竞速——避免每一步都为死机器付出 connect 超时的代价。
+        self._healthy_url: Optional[str] = None
 
     async def authenticate(
         self,
@@ -97,6 +104,9 @@ class LDAPAuthService:
     ) -> LDAPAuthResult:
         """验证用户凭证
 
+        所有 LDAP 服务器并发 connect+bind,谁先成功立即返回;
+        只有在任何一台都不成功时,才等全部结果做错误分类。
+
         Args:
             username: 用户名（域账号）
             password: 密码
@@ -105,85 +115,112 @@ class LDAPAuthService:
             LDAPAuthResult: 认证结果
         """
         try:
-            # 在线程池中执行同步 LDAP 操作
-            result = await asyncio.get_event_loop().run_in_executor(
-                None,
-                self._authenticate_sync,
-                username,
-                password,
-            )
+            # 在线程池中并发执行各服务器的同步 LDAP 操作
+            loop = asyncio.get_event_loop()
+            result = await self._authenticate_race(loop, username, password)
             return result
         except Exception as e:
             SYLogger.error(f"[LDAP] 认证异常: {e}")
             return LDAPAuthResult(success=False, error=str(e))
 
-    def _authenticate_sync(self, username: str, password: str) -> LDAPAuthResult:
-        """同步执行 LDAP 认证"""
-        import ldap3
-        from ldap3.core.exceptions import LDAPException
-
-        # 构建用户 DN
-        user_dn = self._build_user_dn(username)
+    async def _authenticate_race(
+        self, loop: asyncio.AbstractEventLoop, username: str, password: str
+    ) -> LDAPAuthResult:
+        """并发对每台服务器执行 connect+bind(+成功后取用户信息)。
 
-        # 尝试连接各个 LDAP 服务器
-        # 优先返回认证类错误（invalidCredentials 等），而非连接类错误（timeout）。
-        # 避免备用服务器连接超时覆盖了主服务器的真实认证错误（密码错误），误导用户。
-        errors = []
-        for url in self.config.urls:
+        快路径:任一台成功立即返回(LDAPAuthResult.success=True);
+        活机器报认证类错误(密码错误)也立即返回——密码在任何一台 DC
+        上都错,等其它服务器不会改变结论,不陪死机器耗超时;
+        仅全部失败(连接类错误居多)时收齐错误做分类。
+        """
+        auth_keywords = [
+            "invalidcredentials",
+            "invalidattribute",
+            "insufficientaccess",
+            "密码",
+            "credential",
+        ]
+
+        def _is_auth_error(msg: str) -> bool:
+            lm = msg.lower()
+            return any(kw in lm for kw in auth_keywords)
+
+        def _try_one(url: str):
+            """单台服务器认证;成功返回 (url, result, None),失败返回 (url, None, err)。"""
             try:
-                # 创建连接（移除末尾的斜杠，设置连接超时）
-                clean_url = url.rstrip("/")
-                server = ldap3.Server(
-                    clean_url,
-                    get_info=ldap3.ALL,
-                    connect_timeout=5,  # 连接超时 5 秒
-                )
-                conn = ldap3.Connection(
-                    server,
-                    user=user_dn,
-                    password=password,
-                    auto_bind=True,
-                    receive_timeout=10,  # 接收超时 10 秒
-                )
-
-                # 认证成功，获取用户信息
-                user_info = self._get_user_info(conn, username)
-                conn.unbind()
-
-                SYLogger.info(f"[LDAP] 用户 {username} 认证成功")
-                return LDAPAuthResult(
-                    success=True,
-                    user=user_info,
-                )
-
-            except LDAPException as e:
-                errors.append((url, str(e)))
-                SYLogger.warning(f"[LDAP] 连接 {url} 失败: {e}")
-                continue
+                result = self._authenticate_one(username, password, url)
+                return url, result, None
+            except LDAPAuthError as e:
+                return url, None, str(e)
+
+        tasks = [
+            loop.run_in_executor(None, _try_one, url.rstrip("/"))
+            for url in self.config.urls
+        ]
+
+        errors: list = []
+        for fut in asyncio.as_completed(tasks):
+            url, result, err = await fut
+            if err is None:
+                self._healthy_url = url
+                return result
+            errors.append((url, err))
+            # 认证类错误是终局结论,立即返回,不等仍在 dial 的死机器
+            if _is_auth_error(err):
+                SYLogger.error(f"[LDAP] 用户 {username} 认证失败: {err}")
+                return LDAPAuthResult(success=False, error=f"认证失败: {err}")
 
-        # 优先返回认证类错误（密码错误等），而不是连接超时
-        # 按优先级排序：invalidCredentials / invalidAttribute / insufficientAccess 优先
-        auth_keywords = ["invalidcredentials", "invalidattribute", "insufficientaccess", "密码", "credential"]
+        # 全部失败:优先返回认证类错误,其次第一台(通常是主服务器)的连接错误
         for url, err in errors:
-            if any(kw in err.lower() for kw in auth_keywords):
+            if _is_auth_error(err):
                 SYLogger.error(f"[LDAP] 用户 {username} 认证失败: {err}")
-                return LDAPAuthResult(
-                    success=False,
-                    error=f"认证失败: {err}",
-                )
-
-        # 全是连接类错误，返回第一个（通常是主服务器）
+                return LDAPAuthResult(success=False, error=f"认证失败: {err}")
         if errors:
             first_err = errors[0][1]
             SYLogger.error(f"[LDAP] 用户 {username} 认证失败: {first_err}")
-            return LDAPAuthResult(
-                success=False,
-                error=f"认证失败: {first_err}",
-            )
+            return LDAPAuthResult(success=False, error=f"认证失败: {first_err}")
 
         SYLogger.error(f"[LDAP] 用户 {username} 认证失败: 未知错误")
         return LDAPAuthResult(success=False, error="认证失败: 未知错误")
 
+    def _authenticate_one(
+        self, username: str, password: str, url: str
+    ) -> LDAPAuthResult:
+        """对单台 LDAP 服务器执行 connect+bind+取用户信息。
+
+        Raises:
+            LDAPAuthError: 连接或绑定失败(含密码错误),错误消息交由上层分类
+        """
+        import ldap3
+        from ldap3.core.exceptions import LDAPException
+
+        user_dn = self._build_user_dn(username)
+
+        try:
+            server = ldap3.Server(
+                url,
+                get_info=ldap3.ALL,
+                connect_timeout=5,  # 连接超时 5 秒
+            )
+            conn = ldap3.Connection(
+                server,
+                user=user_dn,
+                password=password,
+                auto_bind=True,
+                receive_timeout=10,  # 接收超时 10 秒
+            )
+
+            # 认证成功,获取用户信息(同一连接内完成,不再二次拨号)
+            user_info = self._get_user_info(conn, username)
+            conn.unbind()
+
+            SYLogger.info(f"[LDAP] 用户 {username} 经 {url} 认证成功")
+            return LDAPAuthResult(success=True, user=user_info)
+
+        except LDAPException as e:
+            SYLogger.warning(f"[LDAP] 连接 {url} 失败: {e}")
+            raise LDAPAuthError(str(e)) from e
+
     def _build_user_dn(self, username: str) -> str:
         """构建用户 DN
 
@@ -279,16 +316,21 @@ class LDAPAuthService:
             return None
 
     def _search_user_sync(self, username: str) -> Optional[LDAPUser]:
-        """同步执行用户搜索"""
+        """同步执行用户搜索;记住的 healthy 服务器优先,失败再逐台回退"""
         import ldap3
         from ldap3.core.exceptions import LDAPException
 
         bind_user = self._build_bind_dn(self.config.username)
 
-        for url in self.config.urls:
+        # healthy 机器优先(它最近验证过可用),其余按配置顺序回退
+        urls = [u.rstrip("/") for u in self.config.urls]
+        if self._healthy_url and self._healthy_url in urls:
+            urls = [self._healthy_url] + [u for u in urls if u != self._healthy_url]
+
+        for url in urls:
             try:
                 server = ldap3.Server(
-                    url.rstrip("/"),
+                    url,
                     get_info=ldap3.ALL,
                     connect_timeout=5,
                 )
@@ -305,10 +347,13 @@ class LDAPAuthService:
                 conn.unbind()
 
                 if user_info.dn:
+                    self._healthy_url = url
                     return user_info
 
             except LDAPException as e:
                 SYLogger.warning(f"[LDAP] 搜索连接 {url} 失败: {e}")
+                if url == self._healthy_url:
+                    self._healthy_url = None
                 continue
 
         return None

{sycommon_python_lib-0.2.10a5 → sycommon_python_lib-0.2.10b7}/src/sycommon/database/async_database_service.py

@@ -28,7 +28,11 @@ class AsyncDatabaseService(metaclass=SingletonMeta):
     _setup_args = None
 
     @staticmethod
-    async def setup_database(config: dict, shareConfigKey: str):
+    async def setup_database(config: dict, shareConfigKey: str = None):
+        # shareConfigKey 缺省时取 app.yaml 的 Name 服务名
+        # (对齐 Services.plugins 的 database_service 默认值)
+        if not shareConfigKey:
+            shareConfigKey = (config or {}).get('Name', '')
         common = NacosService(config).share_configs.get(shareConfigKey, {})
         if common and common.get('spring', {}).get('datasource', None):
             databaseConfig = common.get('spring', {}).get('datasource', None)

{sycommon_python_lib-0.2.10a5 → sycommon_python_lib-0.2.10b7}/src/sycommon/database/database_service.py

@@ -15,7 +15,11 @@ class DatabaseService(metaclass=SingletonMeta):
     _setup_args = None
 
     @staticmethod
-    def setup_database(config: dict, shareConfigKey: str):
+    def setup_database(config: dict, shareConfigKey: str = None):
+        # shareConfigKey 缺省时取 app.yaml 的 Name 服务名
+        # (对齐 Services.plugins 的 database_service 默认值)
+        if not shareConfigKey:
+            shareConfigKey = (config or {}).get('Name', '')
         common = NacosService(config).share_configs.get(shareConfigKey, {})
         if common and common.get('spring', {}).get('datasource', None):
             databaseConfig = common.get('spring', {}).get('datasource', None)