sycommon-python-lib 0.2.5a36__py3-none-any.whl → 0.2.5a38__py3-none-any.whl

sycommon/agent/deep_agent.py

@@ -104,27 +104,35 @@ def _patch_agent_streaming(agent):
         from langchain_core.messages import AIMessageChunk as _AIC, AIMessage as _AIM
         from langchain_core.runnables.config import var_child_runnable_config
 
-        print(f"[StreamingPatch] agent.nodes: {list(agent.nodes.keys())}", flush=True)
+        print(
+            f"[StreamingPatch] agent.nodes: {list(agent.nodes.keys())}", flush=True)
         node = agent.nodes.get("model")
         if node is None:
             print("[StreamingPatch] model node not found, skip", flush=True)
-            SYLogger.warning("[DeepAgent] model node not found, skip streaming patch")
+            SYLogger.warning(
+                "[DeepAgent] model node not found, skip streaming patch")
             return
 
         inner = node.node  # RunnableSeq
-        print(f"[StreamingPatch] inner type: {type(inner).__name__}", flush=True)
+        print(
+            f"[StreamingPatch] inner type: {type(inner).__name__}", flush=True)
         if not hasattr(inner, 'steps') or not inner.steps:
             print(f"[StreamingPatch] no steps, inner={inner}", flush=True)
-            SYLogger.warning("[DeepAgent] model node has no steps, skip streaming patch")
+            SYLogger.warning(
+                "[DeepAgent] model node has no steps, skip streaming patch")
             return
 
-        step0 = inner.steps[0]  # RunnableCallable(trace=False, afunc=amodel_node)
-        print(f"[StreamingPatch] step0 type: {type(step0).__name__}, trace={getattr(step0, 'trace', 'N/A')}", flush=True)
+        # RunnableCallable(trace=False, afunc=amodel_node)
+        step0 = inner.steps[0]
+        print(
+            f"[StreamingPatch] step0 type: {type(step0).__name__}, trace={getattr(step0, 'trace', 'N/A')}", flush=True)
         afunc = getattr(step0, "afunc", None)  # amodel_node
         if afunc is None or afunc.__closure__ is None:
-            SYLogger.warning("[DeepAgent] amodel_node afunc/closure 缺失, skip streaming patch")
+            SYLogger.warning(
+                "[DeepAgent] amodel_node afunc/closure 缺失, skip streaming patch")
             return
-        print(f"[StreamingPatch] afunc: {afunc.__name__}, freevars={afunc.__code__.co_freevars}", flush=True)
+        print(
+            f"[StreamingPatch] afunc: {afunc.__name__}, freevars={afunc.__code__.co_freevars}", flush=True)
 
         # ---- 按自由变量名定位 cell（不依赖固定索引）----
         def _cell_by_name(fn, name):
@@ -192,7 +200,8 @@ def _patch_agent_streaming(agent):
                     f"[StreamingPatch] clamp max_tokens: "
                     f"context={max_tokens_limit}, max_output={max_output} → {dynamic_max}")
             except Exception as e:
-                SYLogger.warning(f"[StreamingPatch] clamp max_tokens failed: {e}")
+                SYLogger.warning(
+                    f"[StreamingPatch] clamp max_tokens failed: {e}")
 
         async def _patched_execute_model_async(request):
             """替代 factory._execute_model_async: 用 astream + config 实现流式回调。"""
@@ -219,7 +228,8 @@ def _patch_agent_streaming(agent):
                     _summary_text = re.sub(
                         r'</?internal_context_data>', '', _raw, flags=re.DOTALL
                     ).strip()
-                    SYLogger.debug("[DeepAgent] 摘要已从 HumanMessage 提取，将注入 system_message")
+                    SYLogger.debug(
+                        "[DeepAgent] 摘要已从 HumanMessage 提取，将注入 system_message")
                 else:
                     _filtered_messages.append(_msg)
             messages = _filtered_messages
@@ -233,7 +243,8 @@ def _patch_agent_streaming(agent):
                     f"{_summary_text}\n"
                     "</system_context>"
                 )
-                _new_sys = append_to_system_message(request.system_message, _summary_directive)
+                _new_sys = append_to_system_message(
+                    request.system_message, _summary_directive)
                 request = request.override(system_message=_new_sys)
 
             if request.system_message:
@@ -254,7 +265,8 @@ def _patch_agent_streaming(agent):
 
             if not chunks:
                 # astream 无产出时降级到原始 ainvoke（不走流式）
-                SYLogger.warning("[StreamingPatch] astream returned empty, fallback to ainvoke")
+                SYLogger.warning(
+                    "[StreamingPatch] astream returned empty, fallback to ainvoke")
                 output = await model_.ainvoke(messages, config=config)
             else:
                 generation = chunks[0]
@@ -268,8 +280,10 @@ def _patch_agent_streaming(agent):
                         content=ai_message.content,
                         additional_kwargs=ai_message.additional_kwargs,
                         tool_calls=ai_message.tool_calls,
-                        usage_metadata=getattr(ai_message, "usage_metadata", None),
-                        response_metadata=getattr(ai_message, "response_metadata", {}),
+                        usage_metadata=getattr(
+                            ai_message, "usage_metadata", None),
+                        response_metadata=getattr(
+                            ai_message, "response_metadata", {}),
                         id=ai_message.id,
                     )
                 output = ai_message
@@ -277,7 +291,8 @@ def _patch_agent_streaming(agent):
             if _name:
                 output.name = _name
 
-            handled_output = _handle_model_output(output, effective_response_format)
+            handled_output = _handle_model_output(
+                output, effective_response_format)
             return ModelResponse(
                 result=handled_output["messages"],
                 structured_response=handled_output.get("structured_response"),
@@ -289,7 +304,6 @@ def _patch_agent_streaming(agent):
             f"[DeepAgent] _execute_model_async patched (astream + config) "
             f"| langchain={_cur.get('langchain')} core={_cur.get('langchain_core')}")
 
-
     except Exception as e:
         SYLogger.warning(f"[DeepAgent] streaming patch failed: {e}")
 
@@ -437,7 +451,8 @@ class DeepAgent:
             input_state = {"messages": [HumanMessage(content=message)]}
             if rubric:
                 input_state["rubric"] = rubric
-            print(f"[DeepAgent] chat() starting stream, message={repr(message[:80])}", flush=True)
+            print(
+                f"[DeepAgent] chat() starting stream, message={repr(message[:80])}", flush=True)
             async for chunk in self._astream_with_retry(
                 input_state,
                 max_retries=3,
@@ -457,9 +472,12 @@ class DeepAgent:
                         _meta = chunk[1]
                     _msg_type = type(_msg).__name__
                     _content = repr(str(getattr(_msg, 'content', ''))[:80])
-                    _node = _meta.get('langgraph_node', '?') if isinstance(_meta, dict) else '?'
-                    _step = _meta.get('langgraph_step', '?') if isinstance(_meta, dict) else '?'
-                    print(f"[DeepAgent] 2tuple: ns={_ns} msg={_msg_type} node={_node} step={_step} content={_content}", flush=True)
+                    _node = _meta.get('langgraph_node', '?') if isinstance(
+                        _meta, dict) else '?'
+                    _step = _meta.get('langgraph_step', '?') if isinstance(
+                        _meta, dict) else '?'
+                    print(
+                        f"[DeepAgent] 2tuple: ns={_ns} msg={_msg_type} node={_node} step={_step} content={_content}", flush=True)
                 elif isinstance(chunk, tuple) and _chunk_len == 3:
                     namespace_p, _tag_p, payload_p = chunk
                     if isinstance(payload_p, tuple) and len(payload_p) == 2:
@@ -467,13 +485,18 @@ class DeepAgent:
                         _meta = payload_p[1]
                         _msg_type = type(_msg).__name__
                         _content = repr(str(getattr(_msg, 'content', ''))[:80])
-                        _node = _meta.get('langgraph_node', '?') if isinstance(_meta, dict) else '?'
-                        _step = _meta.get('langgraph_step', '?') if isinstance(_meta, dict) else '?'
-                        print(f"[DeepAgent] 3tuple: ns={repr(namespace_p)[:30]} msg={_msg_type} node={_node} step={_step} content={_content}", flush=True)
+                        _node = _meta.get('langgraph_node', '?') if isinstance(
+                            _meta, dict) else '?'
+                        _step = _meta.get('langgraph_step', '?') if isinstance(
+                            _meta, dict) else '?'
+                        print(
+                            f"[DeepAgent] 3tuple: ns={repr(namespace_p)[:30]} msg={_msg_type} node={_node} step={_step} content={_content}", flush=True)
                     else:
-                        print(f"[DeepAgent] 3tuple: payload_type={type(payload_p).__name__}", flush=True)
+                        print(
+                            f"[DeepAgent] 3tuple: payload_type={type(payload_p).__name__}", flush=True)
                 else:
-                    print(f"[DeepAgent] chunk: type={type(chunk).__name__}", flush=True)
+                    print(
+                        f"[DeepAgent] chunk: type={type(chunk).__name__}", flush=True)
                 # 检查取消
                 if cancel_event and cancel_event.is_set():
                     event = ChatEventBuilder.cancelled("任务已取消")
@@ -506,10 +529,13 @@ class DeepAgent:
 
                 # ===== 🔑 诊断日志：详细记录每个 chunk =====
                 _chunk_type = type(chunk).__name__
-                _msg_type = getattr(msg, '__class__.__name__', '?') if msg else 'None'
+                _msg_type = getattr(
+                    msg, '__class__.__name__', '?') if msg else 'None'
                 _ns = namespace if namespace else '()'
-                _node = metadata.get("langgraph_node", "?") if metadata else "?"
-                _step = metadata.get("langgraph_step", "?") if metadata else "?"
+                _node = metadata.get(
+                    "langgraph_node", "?") if metadata else "?"
+                _step = metadata.get(
+                    "langgraph_step", "?") if metadata else "?"
                 _content_preview = ""
                 if isinstance(msg, BaseMessage):
                     _c = msg.content or ""
@@ -531,8 +557,10 @@ class DeepAgent:
                     if msg_type in ("AIMessage", "AIMessageChunk"):
                         usage_meta = getattr(msg, "usage_metadata", None)
                         if usage_meta:
-                            total_input_tokens += usage_meta.get("input_tokens", 0)
-                            total_output_tokens += usage_meta.get("output_tokens", 0)
+                            total_input_tokens += usage_meta.get(
+                                "input_tokens", 0)
+                            total_output_tokens += usage_meta.get(
+                                "output_tokens", 0)
                             if usage_meta.get("input_tokens", 0) > 0:
                                 SYLogger.debug(
                                     f"[DeepAgent] usage_metadata | input={usage_meta.get('input_tokens', 0)} "
@@ -611,10 +639,12 @@ class DeepAgent:
                         await on_event(event)
                     yield event
 
-                print(f"[DeepAgent] post-yield: msg_type={type(msg).__name__}, is_BaseMessage={isinstance(msg, BaseMessage)}", flush=True)
+                print(
+                    f"[DeepAgent] post-yield: msg_type={type(msg).__name__}, is_BaseMessage={isinstance(msg, BaseMessage)}", flush=True)
 
                 if not isinstance(msg, BaseMessage):
-                    print(f"[DeepAgent] SKIPPING non-BaseMessage: {type(msg).__name__}", flush=True)
+                    print(
+                        f"[DeepAgent] SKIPPING non-BaseMessage: {type(msg).__name__}", flush=True)
                     continue
 
                 msg_type = msg.__class__.__name__
@@ -623,14 +653,16 @@ class DeepAgent:
                 # SummarizationMiddleware 会将摘要包装为 HumanMessage（lc_source="summarization"），
                 # 这仅用于模型内部理解上下文，不应展示给用户
                 if msg_type == "HumanMessage" and getattr(msg, "additional_kwargs", {}).get("lc_source") == "summarization":
-                    SYLogger.debug(f"[DeepAgent] 跳过摘要消息 (lc_source=summarization)")
+                    SYLogger.debug(
+                        f"[DeepAgent] 跳过摘要消息 (lc_source=summarization)")
                     continue
 
                 raw_content = msg.content
                 # 🔑 处理 content 为 list 的情况（多模态模型）
                 if isinstance(raw_content, list):
                     content = "".join(
-                        item.get("text", "") if isinstance(item, dict) else str(item)
+                        item.get("text", "") if isinstance(
+                            item, dict) else str(item)
                         for item in raw_content
                     )
                 else:
@@ -639,15 +671,20 @@ class DeepAgent:
                 # 🔑 Defense 3: 清理 AI 输出中的摘要泄漏标签（安全网）
                 # 即使摘要已注入 SystemMessage，模型仍可能在极少数情况下回显标签
                 if msg_type in ("AIMessage", "AIMessageChunk") and content:
+                    _cleaned = False
                     for _pat in [
                         r'<internal_context_data>.*?</internal_context_data>',
                         r'<compressed_history>.*?</compressed_history>',
                         r'<system_context>.*?</system_context>',
                     ]:
                         if re.search(_pat, content, re.DOTALL):
-                            content = re.sub(_pat, '', content, flags=re.DOTALL)
+                            content = re.sub(
+                                _pat, '', content, flags=re.DOTALL)
+                            _cleaned = True
                             SYLogger.warning("[DeepAgent] AI 输出包含摘要泄漏标签，已清理")
-                    content = content.strip()
+                    # 仅在确实清理了泄漏标签时才 strip，避免吞掉正常的换行符
+                    if _cleaned:
+                        content = content.strip()
 
                 if msg_type in ("AIMessage", "AIMessageChunk"):
                     # 🔑 提取 reasoning_content（思考/推理内容）
@@ -683,11 +720,13 @@ class DeepAgent:
                             # 用 (id 或 index) 匹配已记录的 tool_call
                             if tcc_id:
                                 existing_tc = next(
-                                    (tc for tc in current_tool_calls if tc.get("id") == tcc_id), None
+                                    (tc for tc in current_tool_calls if tc.get(
+                                        "id") == tcc_id), None
                                 )
                             elif tcc_index is not None:
                                 existing_tc = next(
-                                    (tc for tc in current_tool_calls if tc.get("_index") == tcc_index), None
+                                    (tc for tc in current_tool_calls if tc.get(
+                                        "_index") == tcc_index), None
                                 )
                             else:
                                 existing_tc = None
@@ -764,7 +803,8 @@ class DeepAgent:
                                     # 非空 args 覆盖（完整解析后的结果）
                                     if tc_args and tc_args != {}:
                                         existing_tc["args"] = tc_args
-                                        existing_tc["_args_buffer"] = json.dumps(tc_args, ensure_ascii=False)
+                                        existing_tc["_args_buffer"] = json.dumps(
+                                            tc_args, ensure_ascii=False)
                                 else:
                                     current_tool_calls.append({
                                         "id": tc_id, "name": tc_name, "args": tc_args,
@@ -844,7 +884,8 @@ class DeepAgent:
                 SYLogger.debug(
                     f"[DeepAgent] AI chunk done | {repr(ai_chunk_buffer[:100])}...")
 
-            print(f"[DeepAgent] FOR LOOP ENDED. stream_step={stream_step}, ai_text_content={repr(ai_text_content[:100])}, tool_calls={len(current_tool_calls)}", flush=True)
+            print(
+                f"[DeepAgent] FOR LOOP ENDED. stream_step={stream_step}, ai_text_content={repr(ai_text_content[:100])}, tool_calls={len(current_tool_calls)}", flush=True)
 
             # 空响应检测：模型被调用但没有产出任何文本
             if not ai_text_content and not ai_chunk_buffer:
@@ -884,7 +925,8 @@ class DeepAgent:
             yield event
             raise
         except Exception as e:
-            print(f"[DeepAgent] chat() Exception: {type(e).__name__}: {e}", flush=True)
+            print(
+                f"[DeepAgent] chat() Exception: {type(e).__name__}: {e}", flush=True)
             import traceback
             traceback.print_exc()
             SYLogger.error(f"[DeepAgent] 聊天异常: {e}")
@@ -936,66 +978,76 @@ class DeepAgent:
         max_sandbox_retries = 3
 
         try:
-          while True:
-            for attempt in range(max_retries):
-                try:
-                    print(f"[DeepAgent] _astream_with_retry: attempt={attempt}, starting astream...", flush=True)
-                    chunk_count = 0
-                    async for chunk in self.agent.astream(
-                        input_data,
-                        config=self.config,
-                        stream_mode="messages",
-                        subgraphs=True
-                    ):
-                        chunk_count += 1
-                        print(f"[DeepAgent] _astream yielding chunk #{chunk_count}", flush=True)
-                        yield chunk
-                        print(f"[DeepAgent] _astream yield returned, consumer processed chunk #{chunk_count}", flush=True)
-                    print(f"[DeepAgent] _astream_with_retry: stream ended normally, total_chunks={chunk_count}", flush=True)
-                    return
-                except (APIConnectionError, APIError, APITimeoutError, ConnectionError, httpx.RemoteProtocolError) as e:
-                    last_error = e
-                    print(f"[DeepAgent] _astream_with_retry: API error: {type(e).__name__}: {e}", flush=True)
-                    if attempt < max_retries - 1:
-                        delay = base_delay * (2 ** attempt)
-                        SYLogger.warning(
-                            f"[DeepAgent] 连接错误: {e}, {delay}秒后重试...")
-                        await asyncio.sleep(delay)
-                    else:
-                        raise last_error
-                except RuntimeError as e:
-                    err_msg = str(e)
-                    is_sandbox_error = "沙箱服务不可用" in err_msg or "Failed to download" in err_msg
-                    if is_sandbox_error and self.recovery_manager and sandbox_retries < max_sandbox_retries:
-                        sandbox_retries += 1
-                        SYLogger.warning(f"[DeepAgent] 沙箱服务不可用，尝试恢复 ({sandbox_retries}/{max_sandbox_retries})...")
-                        recovered = await self.recovery_manager.recover()
-                        if recovered:
-                            SYLogger.info("[DeepAgent] 沙箱已恢复，继续执行")
-                            break
-                        raise
-                    raise
-                except ValueError as e:
-                    err_msg = str(e)
-                    if "Failed to download" in err_msg or "沙箱服务不可用" in err_msg:
-                        if self.recovery_manager and sandbox_retries < max_sandbox_retries:
+            while True:
+                for attempt in range(max_retries):
+                    try:
+                        print(
+                            f"[DeepAgent] _astream_with_retry: attempt={attempt}, starting astream...", flush=True)
+                        chunk_count = 0
+                        async for chunk in self.agent.astream(
+                            input_data,
+                            config=self.config,
+                            stream_mode="messages",
+                            subgraphs=True
+                        ):
+                            chunk_count += 1
+                            print(
+                                f"[DeepAgent] _astream yielding chunk #{chunk_count}", flush=True)
+                            yield chunk
+                            print(
+                                f"[DeepAgent] _astream yield returned, consumer processed chunk #{chunk_count}", flush=True)
+                        print(
+                            f"[DeepAgent] _astream_with_retry: stream ended normally, total_chunks={chunk_count}", flush=True)
+                        return
+                    except (APIConnectionError, APIError, APITimeoutError, ConnectionError, httpx.RemoteProtocolError) as e:
+                        last_error = e
+                        print(
+                            f"[DeepAgent] _astream_with_retry: API error: {type(e).__name__}: {e}", flush=True)
+                        if attempt < max_retries - 1:
+                            delay = base_delay * (2 ** attempt)
+                            SYLogger.warning(
+                                f"[DeepAgent] 连接错误: {e}, {delay}秒后重试...")
+                            await asyncio.sleep(delay)
+                        else:
+                            raise last_error
+                    except RuntimeError as e:
+                        err_msg = str(e)
+                        is_sandbox_error = "沙箱服务不可用" in err_msg or "Failed to download" in err_msg
+                        if is_sandbox_error and self.recovery_manager and sandbox_retries < max_sandbox_retries:
                             sandbox_retries += 1
-                            SYLogger.warning(f"[DeepAgent] Memory 下载失败（沙箱不可达），尝试恢复 ({sandbox_retries}/{max_sandbox_retries})...")
+                            SYLogger.warning(
+                                f"[DeepAgent] 沙箱服务不可用，尝试恢复 ({sandbox_retries}/{max_sandbox_retries})...")
                             recovered = await self.recovery_manager.recover()
                             if recovered:
                                 SYLogger.info("[DeepAgent] 沙箱已恢复，继续执行")
                                 break
-                        # 恢复失败也继续执行（降级：memory 不可用不阻塞聊天）
-                        SYLogger.warning(f"[DeepAgent] Memory 不可用，降级继续执行: {err_msg}")
-                        continue
-                    raise
-            else:
-                break
+                            raise
+                        raise
+                    except ValueError as e:
+                        err_msg = str(e)
+                        if "Failed to download" in err_msg or "沙箱服务不可用" in err_msg:
+                            if self.recovery_manager and sandbox_retries < max_sandbox_retries:
+                                sandbox_retries += 1
+                                SYLogger.warning(
+                                    f"[DeepAgent] Memory 下载失败（沙箱不可达），尝试恢复 ({sandbox_retries}/{max_sandbox_retries})...")
+                                recovered = await self.recovery_manager.recover()
+                                if recovered:
+                                    SYLogger.info("[DeepAgent] 沙箱已恢复，继续执行")
+                                    break
+                            # 恢复失败也继续执行（降级：memory 不可用不阻塞聊天）
+                            SYLogger.warning(
+                                f"[DeepAgent] Memory 不可用，降级继续执行: {err_msg}")
+                            continue
+                        raise
+                else:
+                    break
         except GeneratorExit:
-            print("[DeepAgent] _astream_with_retry: GeneratorExit! Consumer closed the generator!", flush=True)
+            print(
+                "[DeepAgent] _astream_with_retry: GeneratorExit! Consumer closed the generator!", flush=True)
             raise
         except Exception as e:
-            print(f"[DeepAgent] _astream_with_retry: Unexpected exception: {type(e).__name__}: {e}", flush=True)
+            print(
+                f"[DeepAgent] _astream_with_retry: Unexpected exception: {type(e).__name__}: {e}", flush=True)
             raise
 
 
@@ -1047,7 +1099,8 @@ async def create_deep_agent(
     # 等方法在原始 ChatOpenAI 上工作，而不是被 LLMWithTokenTracking 的包装拦截。
     raw_model = getattr(model, 'llm', model)
     if raw_model is not model:
-        print(f"[DeepAgent] 提取原始模型: {type(model).__name__} → {type(raw_model).__name__}", flush=True)
+        print(
+            f"[DeepAgent] 提取原始模型: {type(model).__name__} → {type(raw_model).__name__}", flush=True)
         if hasattr(raw_model, 'streaming'):
             raw_model.streaming = True
 
@@ -1136,10 +1189,12 @@ async def create_deep_agent(
 
         RunnableCallable.__init__ = _patched_rc_init
     except Exception as _patch_err:
-        SYLogger.warning(f"[DeepAgent] RunnableCallable monkey-patch FAILED: {_patch_err}")
+        SYLogger.warning(
+            f"[DeepAgent] RunnableCallable monkey-patch FAILED: {_patch_err}")
 
     agent = _create_deep_agent(**agent_kwargs)
-    print(f"[DeepAgent] Agent created, type={type(agent).__name__}", flush=True)
+    print(
+        f"[DeepAgent] Agent created, type={type(agent).__name__}", flush=True)
 
     # 恢复原始 __init__
     if _original_rc_init is not None:
@@ -1182,7 +1237,11 @@ async def _sync_skills_to_sandbox(
     skills_dir: str,
     backend: HTTPSandboxBackend,
 ) -> None:
-    """同步 skills 到沙箱（按版本检查，版本不一致则覆盖）"""
+    """同步 skills SKILL.md 到沙箱（按版本检查，版本不一致则覆盖）
+
+    只同步 SKILL.md 文件，不同步 scripts/ 等大目录。
+    scripts/ 在 agent 实际调用时由 HTTPSandboxBackend._lazy_sync_skill_from_path 按需同步。
+    """
     if not os.path.isdir(skills_dir):
         return
 
@@ -1222,19 +1281,29 @@ async def _sync_skills_to_sandbox(
                     pass
 
                 if remote_version and remote_version == local_version:
-                    SYLogger.debug(f"[DeepAgent] 技能版本一致，跳过: {skill_name} v{local_version}")
+                    SYLogger.debug(
+                        f"[DeepAgent] 技能版本一致，跳过: {skill_name} v{local_version}")
                     continue
 
                 # 版本不一致或沙箱无版本，删除后重新上传
                 try:
                     await backend.aexecute(f"rm -rf /skills/{skill_name}")
-                    SYLogger.info(f"[DeepAgent] 技能版本不一致，覆盖: {skill_name} ({remote_version or '无版本'} → {local_version})")
+                    SYLogger.info(
+                        f"[DeepAgent] 技能版本不一致，覆盖: {skill_name} ({remote_version or '无版本'} → {local_version})")
                 except Exception as e:
-                    SYLogger.warning(f"[DeepAgent] 删除旧版技能失败: {skill_name}, {e}")
+                    SYLogger.warning(
+                        f"[DeepAgent] 删除旧版技能失败: {skill_name}, {e}")
                     continue
 
-            await backend.async_sync_dirs([(src, f"/skills/{skill_name}")])
-            SYLogger.info(f"[DeepAgent] 同步技能到沙箱: {skill_name} v{local_version}")
+            # 只同步 SKILL.md（不再同步整个目录）
+            if os.path.isfile(local_skill_md):
+                with open(local_skill_md, "rb") as f:
+                    content = f.read()
+                await backend.aupload_files([
+                    (f"/skills/{skill_name}/SKILL.md", content)
+                ])
+                SYLogger.info(
+                    f"[DeepAgent] 同步技能元数据到沙箱: {skill_name} v{local_version} (仅 SKILL.md)")
     except Exception as e:
         SYLogger.warning(f"[DeepAgent] 技能同步失败: {e}")
 
@@ -1244,16 +1313,14 @@ async def _create_sandbox_backend(
     config: AgentConfig,
     project_root: Path,
 ) -> HTTPSandboxBackend:
-    """创建并同步沙箱后端"""
-    sync_dirs = []
+    """创建并同步沙箱后端
 
-    if config.skills_dir:
-        skills_dir = Path(config.skills_dir)
-    else:
-        skills_dir = project_root / "skills"
-    skills_dir.mkdir(parents=True, exist_ok=True)
-    sync_dirs.append((str(skills_dir), "/skills"))
+    注意：skills 目录不再通过 sync_dirs 全量同步，
+    而是由 _sync_skills_to_sandbox() 做版本感知的增量同步。
+    """
+    sync_dirs = []
 
+    # skills 不再通过 sync_dirs 全量同步，改由 _sync_skills_to_sandbox() 按版本增量同步
     if config.memory_dir:
         memory_dir = Path(config.memory_dir)
     else:
@@ -1261,12 +1328,19 @@ async def _create_sandbox_backend(
     memory_dir.mkdir(parents=True, exist_ok=True)
     sync_dirs.append((str(memory_dir), "/memory"))
 
+    # 确定 skills_dir，传递给沙箱后端用于懒同步
+    if config.skills_dir:
+        skills_dir_for_backend = str(Path(config.skills_dir))
+    else:
+        skills_dir_for_backend = str(project_root / "skills")
+
     sandbox_backend = HTTPSandboxBackend.from_nacos(
         service_name=config.sandbox_service_name,
         user_id=user_id,
         timeout=config.sandbox_timeout,
         sync_dirs=sync_dirs,
         auto_sync=True,
+        skills_dir=skills_dir_for_backend,
     )
 
     try:

sycommon/agent/multi_agent_team.py

@@ -655,16 +655,14 @@ async def _create_sandbox_backend_for_team(
     config: TeamConfig,
     project_root: Path,
 ) -> HTTPSandboxBackend:
-    """创建并同步沙箱后端（团队版本）"""
-    sync_dirs = []
+    """创建并同步沙箱后端（团队版本）
 
-    if config.skills_dir:
-        skills_dir = Path(config.skills_dir)
-    else:
-        skills_dir = project_root / "skills"
-    skills_dir.mkdir(parents=True, exist_ok=True)
-    sync_dirs.append((str(skills_dir), "/skills"))
+    注意：skills 目录不再通过 sync_dirs 全量同步，
+    而是由 _sync_skills_to_sandbox() 做版本感知的增量同步。
+    """
+    sync_dirs = []
 
+    # skills 不再通过 sync_dirs 全量同步，改由 _sync_skills_to_sandbox() 按版本增量同步
     if config.memory_dir:
         memory_dir = Path(config.memory_dir)
     else:
@@ -672,6 +670,12 @@ async def _create_sandbox_backend_for_team(
     memory_dir.mkdir(parents=True, exist_ok=True)
     sync_dirs.append((str(memory_dir), "/memory"))
 
+    # 确定 skills_dir，传递给沙箱后端用于懒同步
+    if config.skills_dir:
+        skills_dir_for_backend = str(Path(config.skills_dir))
+    else:
+        skills_dir_for_backend = str(project_root / "skills")
+
     sandbox_backend = HTTPSandboxBackend.from_nacos(
         service_name=config.sandbox_service_name,
         user_id=user_id,
@@ -679,6 +683,7 @@ async def _create_sandbox_backend_for_team(
         sync_dirs=sync_dirs,
         auto_sync=True,
         version=get_env_var('VERSION') or None,
+        skills_dir=skills_dir_for_backend,
     )
 
     # 健康检查

sycommon/agent/sandbox/file_ops.py

@@ -182,6 +182,7 @@ class FileOperationsMixin:
     def ls(self: "HTTPSandboxBackend", path: str) -> LsResult:
         """列出目录内容"""
         try:
+            self._lazy_sync_skill_from_path_sync(path)
             self._ensure_synced_sync()
             SYLogger.info(f"[Sandbox] 列出目录: {path}")
             result = self._post_sync(f"{SANDBOX_API_PREFIX}/ls", {
@@ -198,6 +199,7 @@ class FileOperationsMixin:
     async def als(self: "HTTPSandboxBackend", path: str, *, timeout: int = None) -> LsResult:
         """异步列出目录内容"""
         try:
+            await self._lazy_sync_skill_from_path(path)
             await self._ensure_synced_async()
             SYLogger.info(f"[Sandbox] 异步列出目录: {path}")
             result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/ls", {
@@ -221,6 +223,9 @@ class FileOperationsMixin:
     ) -> ReadResult:
         """读取文件内容"""
         try:
+            # 按需懒同步：检测是否读取 skill 资源
+            self._lazy_sync_skill_from_path_sync(file_path)
+
             self._ensure_synced_sync()
             SYLogger.info(
                 f"[Sandbox] 读取文件: {file_path} (offset={offset}, limit={limit})")
@@ -256,6 +261,9 @@ class FileOperationsMixin:
     ) -> ReadResult:
         """异步读取文件内容"""
         try:
+            # 按需懒同步：检测是否读取 skill 资源
+            await self._lazy_sync_skill_from_path(file_path)
+
             await self._ensure_synced_async()
             SYLogger.info(
                 f"[Sandbox] 异步读取文件: {file_path} (offset={offset}, limit={limit})")
@@ -302,6 +310,7 @@ class FileOperationsMixin:
                 /conversation_history/ 路径）。设为 False 时，文件已存在返回错误。
         """
         try:
+            self._lazy_sync_skill_from_path_sync(file_path)
             self._ensure_synced_sync()
             SYLogger.info(f"[Sandbox] 写入文件: {file_path} ({len(content)} 字符)")
             result = self._post_sync(f"{SANDBOX_API_PREFIX}/write", {
@@ -340,6 +349,7 @@ class FileOperationsMixin:
             timeout: 请求超时时间。
         """
         try:
+            await self._lazy_sync_skill_from_path(file_path)
             await self._ensure_synced_async()
             SYLogger.info(f"[Sandbox] 异步写入文件: {file_path} ({len(content)} 字符)")
             result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/write", {
@@ -374,6 +384,7 @@ class FileOperationsMixin:
     ) -> EditResult:
         """编辑文件"""
         try:
+            self._lazy_sync_skill_from_path_sync(file_path)
             self._ensure_synced_sync()
             result = self._post_sync(f"{SANDBOX_API_PREFIX}/edit", {
                 "file_path": file_path,
@@ -402,6 +413,7 @@ class FileOperationsMixin:
     ) -> EditResult:
         """异步编辑文件"""
         try:
+            await self._lazy_sync_skill_from_path(file_path)
             await self._ensure_synced_async()
             result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/edit", {
                 "file_path": file_path,
@@ -424,6 +436,7 @@ class FileOperationsMixin:
     def glob(self: "HTTPSandboxBackend", pattern: str, path: str | None = None) -> GlobResult:
         """glob 搜索文件"""
         try:
+            self._lazy_sync_skill_from_path_sync(path or "/")
             self._ensure_synced_sync()
             result = self._post_sync(f"{SANDBOX_API_PREFIX}/glob", {
                 "pattern": pattern,
@@ -439,6 +452,7 @@ class FileOperationsMixin:
     async def aglob(self: "HTTPSandboxBackend", pattern: str, path: str | None = None, *, timeout: int = None) -> GlobResult:
         """异步 glob 搜索文件"""
         try:
+            await self._lazy_sync_skill_from_path(path or "/")
             await self._ensure_synced_async()
             result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/glob", {
                 "pattern": pattern,
@@ -456,6 +470,7 @@ class FileOperationsMixin:
     def tree(self: "HTTPSandboxBackend", path: str = "/", max_depth: int = 30, max_files: int = 0) -> TreeResult:
         """以树形结构展示目录"""
         try:
+            self._lazy_sync_skill_from_path_sync(path)
             self._ensure_synced_sync()
             SYLogger.info(f"[Sandbox] tree: {path}")
             result = self._post_sync(f"{SANDBOX_API_PREFIX}/tree", {
@@ -476,6 +491,7 @@ class FileOperationsMixin:
     async def atree(self: "HTTPSandboxBackend", path: str = "/", max_depth: int = 30, max_files: int = 0, *, timeout: int = None) -> TreeResult:
         """异步以树形结构展示目录"""
         try:
+            await self._lazy_sync_skill_from_path(path)
             await self._ensure_synced_async()
             SYLogger.info(f"[Sandbox] 异步 tree: {path}")
             result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/tree", {
@@ -501,6 +517,7 @@ class FileOperationsMixin:
     ) -> GrepResult:
         """搜索文件内容"""
         try:
+            self._lazy_sync_skill_from_path_sync(path or "/")
             self._ensure_synced_sync()
             result = self._post_sync(f"{SANDBOX_API_PREFIX}/grep", {
                 "pattern": pattern,
@@ -534,6 +551,7 @@ class FileOperationsMixin:
     ) -> GrepResult:
         """异步搜索文件内容"""
         try:
+            await self._lazy_sync_skill_from_path(path or "/")
             await self._ensure_synced_async()
             result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/grep", {
                 "pattern": pattern,
@@ -564,6 +582,7 @@ class FileOperationsMixin:
     ) -> DeleteResult:
         """删除文件或文件夹"""
         try:
+            self._lazy_sync_skill_from_path_sync(path)
             self._ensure_synced_sync()
             SYLogger.info(f"[Sandbox] 删除: {path} (recursive={recursive})")
             result = self._post_sync(f"{SANDBOX_API_PREFIX}/delete", {
@@ -593,6 +612,7 @@ class FileOperationsMixin:
     ) -> DeleteResult:
         """异步删除文件或文件夹"""
         try:
+            await self._lazy_sync_skill_from_path(path)
             await self._ensure_synced_async()
             SYLogger.info(f"[Sandbox] 异步删除: {path} (recursive={recursive})")
             result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/delete", {
@@ -618,6 +638,7 @@ class FileOperationsMixin:
     async def astat(self: "HTTPSandboxBackend", path: str, *, timeout: int = None) -> "StatResult":
         """异步检查文件或目录状态"""
         try:
+            await self._lazy_sync_skill_from_path(path)
             await self._ensure_synced_async()
             SYLogger.info(f"[Sandbox] 异步查询文件状态: {path}")
             result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/stat", {

sycommon/agent/sandbox/http_sandbox_backend.py

@@ -14,7 +14,7 @@ import sys
 import tempfile
 import threading
 import requests
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import Optional, List
 
 import aiohttp
@@ -126,6 +126,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         nacos_group: str = "DEFAULT_GROUP",
         token: str = None,
         env: dict[str, str] = None,
+        skills_dir: str = None,
     ):
         """
         初始化 HTTP 沙箱后端
@@ -139,6 +140,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             nacos_service_name: Nacos 服务名（用于故障转移时重新发现服务）
             nacos_group: Nacos 服务分组
             env: 注入到沙箱的环境变量字典，每次执行命令时自动前置 export
+            skills_dir: 本地 skills 目录路径，用于 execute 时按需懒同步 scripts/
         """
         self._base_url = base_url.rstrip("/")
         self._user_id = user_id.lower().replace(" ", "") if user_id else user_id
@@ -149,6 +151,10 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         self._workspace_verified = False
         self._local_mode: Optional[bool] = None
 
+        # Skills 懒同步：记录本地 skills 目录，访问时按需同步整个 skill 子目录
+        self._skills_dir = skills_dir
+        self._synced_skills: set[str] = set()  # 已完整同步的 skill 名称
+
         # Token authentication: instance-level > env var
         self._token = token if token is not None else os.environ.get(
             "SANDBOX_TOKEN", "")
@@ -244,6 +250,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         auto_sync: bool = False,
         load_balance: bool = True,
         env: dict[str, str] = None,
+        skills_dir: str = None,
     ) -> "HTTPSandboxBackend":
         """
         从 Nacos 服务发现创建后端实例
@@ -257,6 +264,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             sync_dirs: 要同步的目录列表 [(本地路径, 沙箱路径), ...]
             auto_sync: 是否在首次文件操作时自动同步
             load_balance: 是否基于 user_id 进行负载均衡（默认 True）
+            skills_dir: 本地 skills 目录路径，用于 execute 时按需懒同步 scripts/
 
         Returns:
             HTTPSandboxBackend 实例
@@ -279,6 +287,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 sync_dirs=sync_dirs,
                 auto_sync=auto_sync,
                 env=env,
+                skills_dir=skills_dir,
             )
 
         from sycommon.synacos.nacos_service import NacosService
@@ -330,6 +339,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             nacos_service_name=service_name,
             nacos_group=group,
             env=env,
+            skills_dir=skills_dir,
         )
 
     @classmethod
@@ -344,17 +354,22 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         auto_sync: bool = False,
         load_balance: bool = True,
         env: dict[str, str] = None,
+        skills_dir: str = None,
     ) -> "HTTPSandboxBackend":
         """异步从 Nacos 服务发现创建后端实例"""
         return await asyncio.to_thread(
             cls.from_nacos,
-            service_name, user_id, group, version, timeout, sync_dirs, auto_sync, load_balance, env,
+            service_name, user_id, group, version, timeout, sync_dirs, auto_sync, load_balance, env, skills_dir,
         )
 
     # ============== 内部方法 - 同步版本 ==============
 
     def _refresh_from_nacos_and_switch_sync(self) -> bool:
-        """从 Nacos 重新获取服务实例并切换（同步版本）"""
+        """从 Nacos 重新获取服务实例并切换（同步版本）
+
+        优先从 MinIO 恢复用户文件到新沙箱，避免沙箱间互相迁移脏数据。
+        只有 MinIO 不可用时才尝试从旧沙箱拉取。
+        """
         # 防止递归：如果在故障转移过程中再次调用，直接返回 False
         if getattr(self, '_in_failover', False):
             SYLogger.warning("[Sandbox] 已在故障转移过程中，跳过重复调用")
@@ -399,33 +414,40 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 old_url = self._base_url
                 SYLogger.info(f"[Sandbox] 准备切换服务: {old_url} -> {new_url}")
 
-                # 1. 先从旧服务下载工作空间文件
-                workspace_files = []
-                try:
-                    sync_result = self._sync_workspace_sync()
-                    workspace_files = sync_result.get("files", [])
-                    SYLogger.info(
-                        f"[Sandbox] 从旧服务获取 {len(workspace_files)} 个工作空间文件")
-                except Exception as e:
-                    SYLogger.warning(f"[Sandbox] 获取工作空间文件失败: {e}")
-
-                # 2. 切换到新服务
+                # 1. 切换到新服务
                 self._base_url = new_url
                 self._synced = False
 
-                # 3. 同步配置的目录到新服务
+                # 2. 同步配置的目录到新服务（skills, memory 等本地文件）
                 if self._sync_dirs:
                     SYLogger.info(f"[Sandbox] 重新同步配置目录到新服务...")
                     self._sync_sync()
 
-                # 4. 上传工作空间文件到新服务
-                if workspace_files:
-                    SYLogger.info(
-                        f"[Sandbox] 上传 {len(workspace_files)} 个工作空间文件到新服务...")
-                    upload_result = self._upload_workspace_files_sync(
-                        workspace_files)
+                # 3. 优先从 MinIO 恢复用户工作空间文件
+                workspace_restored = False
+                try:
+                    from sycommon.agent.sandbox.minio_sync import MinioSyncService
+                    minio = MinioSyncService()
+                    if minio.is_available():
+                        SYLogger.info(
+                            f"[Sandbox] 从 MinIO 恢复用户文件到新沙箱...")
+                        import asyncio
+                        loop = asyncio.new_event_loop()
+                        try:
+                            restored = loop.run_until_complete(
+                                minio.restore_from_minio(self, self._user_id))
+                            workspace_restored = restored > 0
+                            SYLogger.info(
+                                f"[Sandbox] MinIO 恢复完成: {restored} 个文件")
+                        finally:
+                            loop.close()
+                except Exception as e:
+                    SYLogger.warning(
+                        f"[Sandbox] MinIO 恢复失败: {e}")
+
+                if not workspace_restored:
                     SYLogger.info(
-                        f"[Sandbox] 工作空间迁移完成: 成功 {upload_result['success']}, 失败 {upload_result['failed']}")
+                        f"[Sandbox] MinIO 无可用数据，新沙箱将从空工作空间开始")
 
                 SYLogger.info(f"[Sandbox] 服务切换完成: {old_url} -> {new_url}")
                 return True
@@ -702,9 +724,17 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             )
 
     async def aexecute(self, command: str, *, timeout: int = None) -> ExecuteResponse:
-        """异步执行 shell 命令（服务端负责路径隔离和目录初始化）"""
+        """异步执行 shell 命令（服务端负责路径隔离和目录初始化）
+
+        如果命令引用了 /skills/<name>/ 下的资源，
+        会自动按需同步该 skill 的整个目录到沙箱。
+        """
         command = self._inject_env(command)
         SYLogger.info(f"[Sandbox] aexecute 开始: command={command}")
+
+        # 按需懒同步：检测命令中是否引用了 skill 资源
+        await self._lazy_sync_skill_from_path(command)
+
         await self._ensure_synced_async()
         SYLogger.info(f"[Sandbox] _ensure_synced_async 完成，开始执行命令: {command}")
         try:
@@ -728,6 +758,79 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 truncated=False
             )
 
+    async def _lazy_sync_skill_from_path(self, path: str) -> None:
+        """从文件路径中检测是否访问了 skill 资源，按需同步整个 skill 目录
+
+        检测路径中是否包含 /skills/<name>/ 模式（不限 scripts/，覆盖
+        assets/、references/ 及任意自定义子目录）。
+        如果该 skill 尚未同步，则上传整个 skill 目录到沙箱。
+        """
+        if not self._skills_dir:
+            return
+
+        import re
+        # 匹配 /skills/<skill_name>/ 或 skills/<skill_name>/
+        match = re.search(r'/skills/([a-zA-Z0-9_\-]+)/', path)
+        if not match:
+            match = re.search(r'(?:^|\s|")skills/([a-zA-Z0-9_\-]+)/', path)
+        if not match:
+            return
+
+        skill_name = match.group(1)
+        if skill_name in self._synced_skills:
+            return
+
+        skill_dir = os.path.join(self._skills_dir, skill_name)
+        if not os.path.isdir(skill_dir):
+            self._synced_skills.add(skill_name)
+            return
+
+        try:
+            await self.async_sync_dirs([
+                (skill_dir, f"/skills/{skill_name}")
+            ])
+            self._synced_skills.add(skill_name)
+            SYLogger.info(
+                f"[Sandbox] 懒同步技能目录: {skill_name}/")
+        except Exception as e:
+            SYLogger.warning(
+                f"[Sandbox] 懒同步技能目录失败: {skill_name}, {e}")
+
+    def _lazy_sync_skill_from_path_sync(self, path: str) -> None:
+        """同步版本的懒同步（在同步文件操作中调用）
+
+        内部使用 asyncio.run_coroutine_threadsafe 或回退到同步上传。
+        """
+        if not self._skills_dir:
+            return
+
+        import re
+        match = re.search(r'/skills/([a-zA-Z0-9_\-]+)/', path)
+        if not match:
+            match = re.search(r'(?:^|\s|")skills/([a-zA-Z0-9_\-]+)/', path)
+        if not match:
+            return
+
+        skill_name = match.group(1)
+        if skill_name in self._synced_skills:
+            return
+
+        skill_dir = os.path.join(self._skills_dir, skill_name)
+        if not os.path.isdir(skill_dir):
+            self._synced_skills.add(skill_name)
+            return
+
+        try:
+            # 同步版本直接调用同步上传方法
+            self._upload_directory_sync(
+                skill_dir, f"/skills/{skill_name}", mode="full")
+            self._synced_skills.add(skill_name)
+            SYLogger.info(
+                f"[Sandbox] 懒同步技能目录(sync): {skill_name}/")
+        except Exception as e:
+            SYLogger.warning(
+                f"[Sandbox] 懒同步技能目录失败(sync): {skill_name}, {e}")
+
     async def _sync_async(self, *, timeout: int = None) -> dict:
         """同步目录（异步版本）
 
@@ -855,7 +958,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
 
                     local_file = Path(root) / file
                     relative_path = local_file.relative_to(local_path)
-                    sandbox_path = str(Path(remote_path) / relative_path)
+                    sandbox_path = str(PurePosixPath(remote_path) / relative_path.as_posix())
                     result.append((sandbox_path, local_file))
             return result
 
@@ -1236,7 +1339,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
 
                 local_file = Path(root) / file
                 relative_path = local_file.relative_to(local_path)
-                sandbox_path = str(Path(remote_path) / relative_path)
+                sandbox_path = str(PurePosixPath(remote_path) / relative_path.as_posix())
                 files_to_upload.append((sandbox_path, local_file))
 
         SYLogger.info(f"[Sandbox] 准备上传 {len(files_to_upload)} 个文件到沙箱")

sycommon/agent/sandbox/minio_sync.py

@@ -218,6 +218,19 @@ class MinioSyncService(metaclass=SingletonMeta):
         """异步删除 MinIO 中指定前缀下的所有对象"""
         return await asyncio.to_thread(self.remove_prefix, prefix)
 
+    async def cleanup_user_history(self, user_id: str) -> None:
+        """清理用户沙箱对话历史和工具缓存（沙箱 + MinIO 双删）
+
+        用于新建会话/重置对话时，确保沙箱和 MinIO 中的
+        conversation_history 和 large_tool_results 都被清除，
+        避免 restore_from_minio 把旧文件同步回来。
+        """
+        uid = user_id.lower().replace(" ", "")
+        await asyncio.gather(
+            self.aremove_prefix(f"{uid}/current/conversation_history/"),
+            self.aremove_prefix(f"{uid}/current/large_tool_results/"),
+        )
+
     # ============== 查找最近副本 ==============
 
     def find_latest_object_key(self, user_id: str, file_path: str) -> Optional[str]:
@@ -303,7 +316,10 @@ class MinioSyncService(metaclass=SingletonMeta):
     async def sync_sandbox_to_minio(self, sandbox_backend, user_id: str) -> int:
         """扫描沙箱目录，增量同步文件到 MinIO
 
-        存储到 {user_id}/current/ 目录，只上传新增或修改的文件。
+        存储到 {user_id}/current/ 目录：
+        - 上传新增或修改的文件
+        - 删除 MinIO 中存在但沙箱中已不存在的文件（双向同步）
+
         max_files=0 表示不限制，tree 返回全部文件。
         下载/上传采用并发（每批 CONCURRENT_BATCH 个），避免串行太慢。
 
@@ -329,6 +345,13 @@ class MinioSyncService(metaclass=SingletonMeta):
 
         sandbox_files = self.collect_sandbox_files(tree_result)
         if not sandbox_files:
+            # 沙箱为空，清理 MinIO 中该用户的所有文件
+            try:
+                removed = await self.aremove_prefix(f"{user_id.lower()}/current/")
+                if removed > 0:
+                    SYLogger.info(f"[MinIO] 沙箱为空，清理 MinIO: user={user_id}, removed={removed}")
+            except Exception as e:
+                SYLogger.warning(f"[MinIO] 沙箱为空时清理 MinIO 失败: {e}")
             return 0
 
         # 2. 确定存储目录
@@ -353,17 +376,36 @@ class MinioSyncService(metaclass=SingletonMeta):
             SYLogger.warning(f"[MinIO] 列出已有副本失败，将全量上传: {e}")
 
         # 4. 找出需要同步的文件（新增的不在 MinIO 中）
+        sandbox_file_set = set(sandbox_files)
         changed_files = [
             fp for fp in sandbox_files if fp not in existing_objects]
 
+        # 5. 找出需要删除的文件（MinIO 中存在但沙箱中已不存在）
+        deleted_files = [
+            fp for fp in existing_objects if fp not in sandbox_file_set]
+
+        # 删除 MinIO 中的孤立文件
+        if deleted_files:
+            removed_count = 0
+            for fp in deleted_files:
+                try:
+                    object_key = f"{prefix}{fp}"
+                    await self.aremove_object(object_key)
+                    removed_count += 1
+                except Exception as e:
+                    SYLogger.warning(f"[MinIO] 删除孤立文件失败: {fp}, {e}")
+            if removed_count > 0:
+                SYLogger.info(
+                    f"[MinIO] 清理孤立文件: user={user_id}, removed={removed_count}")
+
         if not changed_files:
-            SYLogger.info(f"[MinIO] 所有文件均无变化，跳过同步: user={user_id}")
+            SYLogger.info(f"[MinIO] 所有文件均无变化: user={user_id}")
             return 0
 
         SYLogger.info(
             f"[MinIO] 检测到 {len(changed_files)} 个文件有变化: user={user_id}")
 
-        # 5. 并发下载并上传变化文件
+        # 6. 并发下载并上传变化文件
         synced = await self._sync_batch(sandbox_backend, changed_files, existing_objects, prefix)
 
         SYLogger.info(

sycommon/auth/wecom_ldap_service.py

@@ -258,6 +258,81 @@ class WeComLDAPService(metaclass=SingletonMeta):
             async with session.get(url, params=params) as resp:
                 return await resp.json()
 
+    async def _wecom_post(self, path: str, json_body: dict = None) -> dict:
+        """封装企微 POST 请求"""
+        token = await self._get_access_token()
+        url = f"https://qyapi.weixin.qq.com{path}?access_token={token}"
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(url, json=json_body or {}) as resp:
+                return await resp.json()
+
+    async def _decode_open_userid(self, open_userid: str) -> Optional[str]:
+        """将企微密文 open_userid 转换为明文 userid
+
+        当 userid 长度超过 20 位时，大概率是智能机器人的密文 open_userid，
+        需要通过 batch/openuserid_to_userid 接口解码。
+
+        Args:
+            open_userid: 密文格式的企微用户ID
+
+        Returns:
+            解码后的明文 userid，失败返回 None
+        """
+        try:
+            data = await self._wecom_post(
+                "/cgi-bin/batch/openuserid_to_userid",
+                {"open_userid_list": [open_userid]},
+            )
+            if data.get("errcode") != 0:
+                SYLogger.warning(
+                    f"[WeComLDAP] open_userid 解码失败: {data}"
+                )
+                return None
+
+            result_list = data.get("userid_list", [])
+            if not result_list:
+                SYLogger.warning(
+                    f"[WeComLDAP] open_userid 解码结果为空: {data}"
+                )
+                return None
+
+            item = result_list[0]
+            # 单条解码失败时 errcode 非 0
+            if item.get("errcode", 0) != 0:
+                SYLogger.warning(
+                    f"[WeComLDAP] open_userid {open_userid} 解码失败: {item}"
+                )
+                return None
+
+            decoded = item.get("userid", "")
+            if decoded:
+                logging.info(
+                    f"[WeComLDAP] open_userid 解码成功: {open_userid} -> {decoded}"
+                )
+            return decoded or None
+
+        except Exception as e:
+            SYLogger.error(f"[WeComLDAP] open_userid 解码异常: {e}")
+            return None
+
+    async def _try_decode_userid(self, userid: str) -> str:
+        """尝试解码 userid，超过 20 位时自动尝试 open_userid 解码
+
+        解码失败则原样返回，不影响后续流程。
+
+        Args:
+            userid: 原始企微 userid
+
+        Returns:
+            解码后的 userid 或原始 userid
+        """
+        if len(userid) <= 20:
+            return userid
+
+        decoded = await self._decode_open_userid(userid)
+        return decoded if decoded else userid
+
     async def _get_wecom_user(self, userid: str) -> Optional[dict]:
         """获取单个企微用户详情"""
         data = await self._wecom_get(
@@ -462,14 +537,20 @@ class WeComLDAPService(metaclass=SingletonMeta):
     async def get_user_info(self, wecom_userid: str) -> WeComLDAPUser:
         """通过企微 userid 获取关联的 LDAP 完整用户信息
 
+        当 userid 超过 20 位时，自动尝试通过 batch/openuserid_to_userid
+        接口将密文 open_userid 解码为明文 userid。
+
         Args:
-            wecom_userid: 企微用户ID（如 "0633", "SZ0888"）
+            wecom_userid: 企微用户ID（如 "0633", "SZ0888"，或密文 open_userid）
 
         Returns:
             WeComLDAPUser: 合并后的用户信息，包含 LDAP 域账号详情
         """
+        # 0. 尝试解码密文 open_userid
+        decoded_userid = await self._try_decode_userid(wecom_userid)
+
         # 1. 从企微获取用户信息
-        user_data = await self._get_wecom_user(wecom_userid)
+        user_data = await self._get_wecom_user(decoded_userid)
         if not user_data:
             return WeComLDAPUser(wecom_userid=wecom_userid, wecom_name="")
 
@@ -477,7 +558,10 @@ class WeComLDAPService(metaclass=SingletonMeta):
         ldap_index = await self._get_ldap_index()
 
         # 3. 合并返回
-        return await self._build_wecom_ldap_user(user_data, ldap_index)
+        result = await self._build_wecom_ldap_user(user_data, ldap_index)
+        # 保留原始传入的 wecom_userid
+        result.wecom_userid = wecom_userid
+        return result
 
     async def get_all_users(self) -> List[WeComLDAPUser]:
         """获取全量企微用户并关联 LDAP 信息

{sycommon_python_lib-0.2.5a36.dist-info → sycommon_python_lib-0.2.5a38.dist-info}/METADATA

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

{sycommon_python_lib-0.2.5a36.dist-info → sycommon_python_lib-0.2.5a38.dist-info}/RECORD

@@ -129,16 +129,16 @@ sycommon/services.py,sha256=pUcV0xFrn1hrArD9YwE8m6CMrrWPwNBAqUIWhgsVkzY,24943
 sycommon/agent/__init__.py,sha256=mxceAeUifQ-DKvWp7ZEJIFlmOCb5wpYHPGQw3rwEN8I,4378
 sycommon/agent/agent_manager.py,sha256=UhhaekEumT7g4v_Z1UB4jTp13X0n8M8erYaQdkGGWkA,13620
 sycommon/agent/chat_events.py,sha256=t7qWa6OrIWLfqtd1AnqaVP67QWkn1JxpCBTZYQpoLuM,14226
-sycommon/agent/deep_agent.py,sha256=gG05Uqh01L56J1DGkuUcGPwSRmQVifw0AdJa0E3xK-g,60787
-sycommon/agent/multi_agent_team.py,sha256=UjtJCjq-bHFLvdN6n__Bhb_w-hV8EKBKyTTb7T1n8l8,26385
+sycommon/agent/deep_agent.py,sha256=VusZURT_SKsMjje7rmUNjtS01Ootqr2C_fq5eORXAJY,63333
+sycommon/agent/multi_agent_team.py,sha256=SRCZHswfflU1w38_YaF0pqh20qa5N5xqcGAVCBoZzmM,26675
 sycommon/agent/summarization_utils.py,sha256=fiwvKYE_eQc1EtBiPT4UyOZoqQdd4JwEsLRDsJNioLQ,14928
 sycommon/agent/mcp/__init__.py,sha256=iKrdDhIrFsNIkqG_kgcwNe-nOiM6uVfolKv44LfQ-FQ,636
 sycommon/agent/mcp/models.py,sha256=zda4ho-UTYOJ5oPAZPZ-vxhfDRLghUCsMroHnA2A2QQ,1490
 sycommon/agent/mcp/tool_loader.py,sha256=OQa-lE7RL2s3Lqh-kNOKaUrb130hvorB_HjyFBqZBZs,10960
 sycommon/agent/sandbox/__init__.py,sha256=jR7LlkD4J4Y6QYyRXQClkwmqDBCCPmycV_hQV9p9YHw,4621
-sycommon/agent/sandbox/file_ops.py,sha256=JwxGwZzcjUEZ8bvomVe-pjVqneODG4_zl5142g71Qdc,24720
-sycommon/agent/sandbox/http_sandbox_backend.py,sha256=_l7guM-sv4XduE9NTNVLPyRTjZZIGR4qefJUTc8e5q4,59199
-sycommon/agent/sandbox/minio_sync.py,sha256=d1kuWllvyAvAMsFZCP0OdHEQtXN9BEIgHbupC31BjSk,20000
+sycommon/agent/sandbox/file_ops.py,sha256=sqNxlrrzvgJPpHqJB98Us-jsKOYLjal4YUA2Ej7abeU,25852
+sycommon/agent/sandbox/http_sandbox_backend.py,sha256=pBCtNXbuaDn_p_UFaOPKTAGzjcRYhpogbxbiQoOMxG4,63255
+sycommon/agent/sandbox/minio_sync.py,sha256=2vc0uw4IVER9F2W-dja1wbZwEy4G8UVTz4kDaBDzWBE,21919
 sycommon/agent/sandbox/sandbox_pool.py,sha256=eMn8sLakCWf90l6ni2-333QM8oBdX1CflV-WzneFp_k,9133
 sycommon/agent/sandbox/sandbox_recovery.py,sha256=X-eDODx1tmGMh_iTngV6e1ppfDBHpTdkPreJusN5MHY,7358
 sycommon/agent/sandbox/session.py,sha256=TjzC3yFC-VaJ75UwCyL26QX4PRTGNNfQae1FKFuOsYI,2365
@@ -147,7 +147,7 @@ sycommon/auth/ldap_service.py,sha256=fOcpVov5LWJkBk62qbTaltks1c4la7JsbD104KfdBOI
 sycommon/auth/oa_cache.py,sha256=u673y-mK-xo24pSqvfjL68_YFASO2zoxd_iAQ0HetCo,3491
 sycommon/auth/oa_crypto.py,sha256=xpY1R1Bj3KLENXB0TuThB6Eku1E9PYjcoSpOdgDmCgc,1898
 sycommon/auth/oa_service.py,sha256=kLepV9zgqpZoaB73DRPpMA5tJJQjoaDtQPdzBcGXeak,6235
-sycommon/auth/wecom_ldap_service.py,sha256=v8CvPTafvM1qiGHzO48eiD5TjQZa2qAk3OoOG3sMZgY,19799
+sycommon/auth/wecom_ldap_service.py,sha256=CIrGcAr2yD1VTTT3pxzjLCGcH2SxrZrjWM8WkCrx7nk,22829
 sycommon/config/Config.py,sha256=J5VjolqHmhYTBZwTyfSHv9X5cHMfN6kqY2ryHF4LJPw,6785
 sycommon/config/DatabaseConfig.py,sha256=ILiUuYT9_xJZE2W-RYuC3JCt_YLKc1sbH13-MHIOPhg,804
 sycommon/config/ElasticsearchConfig.py,sha256=fO9ZPMgJxSg1-UyDJ90wO6UvYy-jscwPJsSkXgx9qTU,2308
@@ -282,8 +282,8 @@ sycommon/tools/syemail.py,sha256=BDFhgf7WDOQeTcjxJEQdu0dQhnHFPO_p3eI0-Ni3LhQ,561
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
 sycommon/xxljob/__init__.py,sha256=7eoBlQxv-B39IfRSCY2bkqdGYs1QRe1umAWd88VMEEM,86
 sycommon/xxljob/xxljob_service.py,sha256=JIEJaGXhqrTLcyxlyynSrsHg9bBnDNzX-D4qIWLRPUE,6815
-sycommon_python_lib-0.2.5a36.dist-info/METADATA,sha256=BL0G4BxFGVbhaxumOuqyQOMPCunq2-NcEu0SOxfanKk,7914
-sycommon_python_lib-0.2.5a36.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-sycommon_python_lib-0.2.5a36.dist-info/entry_points.txt,sha256=gsR4SssKxDWjRU8ggidzNcdMXDPRSKRS7UaGyNP84Qg,92
-sycommon_python_lib-0.2.5a36.dist-info/top_level.txt,sha256=RgphKrg7nJyZ7irJqbxFr-5H2LUYTvI7ivoWZH2hcD0,29
-sycommon_python_lib-0.2.5a36.dist-info/RECORD,,
+sycommon_python_lib-0.2.5a38.dist-info/METADATA,sha256=ZpqFN3mks3IrAOrr8_85SIT8YLXH8JjT9ukEerUL3bU,7914
+sycommon_python_lib-0.2.5a38.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+sycommon_python_lib-0.2.5a38.dist-info/entry_points.txt,sha256=gsR4SssKxDWjRU8ggidzNcdMXDPRSKRS7UaGyNP84Qg,92
+sycommon_python_lib-0.2.5a38.dist-info/top_level.txt,sha256=RgphKrg7nJyZ7irJqbxFr-5H2LUYTvI7ivoWZH2hcD0,29
+sycommon_python_lib-0.2.5a38.dist-info/RECORD,,