sycommon-python-lib 0.2.10a4__tar.gz → 0.2.10a8__tar.gz

{sycommon_python_lib-0.2.10a4 → sycommon_python_lib-0.2.10a8}/PKG-INFO

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

{sycommon_python_lib-0.2.10a4 → sycommon_python_lib-0.2.10a8}/pyproject.toml

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

{sycommon_python_lib-0.2.10a4 → sycommon_python_lib-0.2.10a8}/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.10a4 → sycommon_python_lib-0.2.10a8}/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.10a4 → sycommon_python_lib-0.2.10a8}/src/sycommon/agent/sandbox/minio_sync.py

@@ -886,6 +886,26 @@ class MinioSyncService(metaclass=SingletonMeta):
 
     # ============== 反向同步（MinIO → 沙箱） ==============
 
+    def _download_object_to_file(self, key: str, dest: str) -> int:
+        """流式下载 MinIO 对象到本地文件（同步，跑在 to_thread），返回字节数。
+
+        替代旧 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(1 * 1024 * 1024):
+                    f.write(chunk)
+                    total += len(chunk)
+            return total
+        finally:
+            resp.close()
+            resp.release_conn()
+
     async def restore_from_minio(self, sandbox_backend, user_id: str) -> int:
         """将 MinIO 中的文件恢复到沙箱
 
@@ -953,9 +973,14 @@ class MinioSyncService(metaclass=SingletonMeta):
         #     打满线程池、挤占主请求路径的沙箱操作。
         # 下载协程先抢本用户 5 槽、再抢全局 100 槽，故实际并发 = min(本用户待下载, 全局剩余)。
         #
-        # 🔑 OOM 兜底：旧实现 gather 所有文件内容进 downloaded 列表后才上传，用户文件多/大
-        #   一次几 GB 进内存。改为【分批流水线】：下 _RESTORE_PER_USER 个→立即上传→字节出作用域
-        #   →下一批。同时按 list_objects 的 size 累加 total_bytes_seen，超 _MAX_RESTORE_BYTES 跳过剩余。
+        # 🔑 OOM 治理（两处放大器都已拔掉）：
+        #   - 上传侧旧实现 gather 所有文件内容进 downloaded 列表后才 base64 整包传沙箱，
+        #     用户文件多/大时一次几 GB 进内存 → 改【分批流水线】+ 每批立即上传；
+        #   - 下载侧旧实现 resp.read() 把整文件读进内存，单个大附件即百 MB 级驻留
+        #     → 改【流式落盘】：MinIO 5MB 块写临时文件 → aupload_stream_from_disk
+        #     逐块读盘推沙箱 → 删临时文件，内存峰值 ≈ 单块，与文件大小无关。
+        #   另按 list_objects 的 size 累加 total_bytes_seen，超 _MAX_RESTORE_BYTES 跳过剩余
+        #   （仅 warning，会话末尾全量扫描兜底）。
         restored = 0
         global_sem = _get_restore_download_sem()
         per_user_sem = asyncio.Semaphore(_RESTORE_PER_USER)
@@ -964,26 +989,43 @@ class MinioSyncService(metaclass=SingletonMeta):
         obj_size_map = {o.object_name[len(prefix):]: (o.size or 0) for o in objects}
 
         async def _download_one(rel_path: str):
-            """下载单个 MinIO 对象到内存，返回 (沙箱绝对路径, 内容) 或 None。"""
+            """下载单个 MinIO 对象【流式落盘】再流式上传沙箱，成功 True 失败 None。
+
+            全程不把整文件 bytes 攒进内存：MinIO 5MB 块写临时文件 →
+            aupload_stream_from_disk 逐块读盘推沙箱 → 删临时文件。
+            """
+            tmp_path = None
             async with per_user_sem, global_sem:
                 try:
-                    def _download_object(bucket, key):
-                        resp = self._client.get_object(bucket, key)
-                        try:
-                            return resp.read()
-                        finally:
-                            resp.close()
-                            resp.release_conn()
-
-                    content = await asyncio.to_thread(
-                        _download_object, self._bucket, f"{prefix}{rel_path}"
+                    import tempfile as _tf
+                    with _tf.NamedTemporaryFile(delete=False) as tmp:
+                        tmp_path = tmp.name
+                    fsize = await asyncio.to_thread(
+                        self._download_object_to_file,
+                        f"{prefix}{rel_path}", tmp_path
+                    )
+                    if fsize == 0:
+                        SYLogger.warning(f"[MinIO] 下载文件为空/失败: {rel_path}")
+                        return None
+                    r = await sandbox_backend.aupload_stream_from_disk(
+                        f"/{rel_path}", tmp_path
                     )
-                    return (f"/{rel_path}", content)
+                    if getattr(r, "error", None):
+                        SYLogger.warning(
+                            f"[MinIO] 上传到沙箱失败: {rel_path}, error={r.error}")
+                        return None
+                    return rel_path
                 except Exception as e:
                     SYLogger.warning(f"[MinIO] 下载文件失败: {rel_path}, error: {e}")
                     return None
+                finally:
+                    if tmp_path:
+                        try:
+                            os.unlink(tmp_path)
+                        except OSError:
+                            pass
 
-        # 分批流水线：下 N 个 → 传 N 个 → 字节随 downloaded/download_results 出作用域释放
+        # 分批流水线：下 N 个 → 传 N 个 → 临时文件随 _download_one finally 删除
         total_bytes_seen = 0
         capped = False
         batch_size = _RESTORE_PER_USER
@@ -1010,18 +1052,7 @@ class MinioSyncService(metaclass=SingletonMeta):
                 *[_download_one(rp) for rp in batch_paths]
             )
             downloaded = [r for r in download_results if r is not None]
-            if not downloaded:
-                continue
-            try:
-                results = await sandbox_backend.aupload_files(downloaded)
-                for r in results:
-                    if not r.error:
-                        restored += 1
-                    else:
-                        SYLogger.warning(
-                            f"[MinIO] 上传到沙箱失败: {r.path}, error={r.error}")
-            except Exception as e:
-                SYLogger.warning(f"[MinIO] 批量上传到沙箱失败: {e}")
+            restored += len(downloaded)
             # downloaded / download_results 到此出作用域，下一批前可被 GC
 
         if capped:

{sycommon_python_lib-0.2.10a4 → sycommon_python_lib-0.2.10a8}/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.10a4 → sycommon_python_lib-0.2.10a8}/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.10a4 → sycommon_python_lib-0.2.10a8}/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)