sycommon-python-lib 0.2.7a44__tar.gz → 0.2.7a46__tar.gz

{sycommon_python_lib-0.2.7a44 → sycommon_python_lib-0.2.7a46}/PKG-INFO

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

{sycommon_python_lib-0.2.7a44 → sycommon_python_lib-0.2.7a46}/pyproject.toml

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

{sycommon_python_lib-0.2.7a44 → sycommon_python_lib-0.2.7a46}/src/sycommon/agent/deep_agent.py

@@ -63,6 +63,7 @@ from sycommon.agent.middleware.sensitive_guard import SensitiveGuardMiddleware
 from deepagents.middleware.summarization import create_summarization_tool_middleware  # noqa: F401 保留 re-export
 from sycommon.agent.summarization_utils import build_summarization_middleware
 from sycommon.agent.resume_compactor import maybe_compact_before_resume
+import sycommon.agent.reasoning_content_patch  # noqa: F401  提取 reasoning_content/reasoning 字段，避免思考型模型被判空响应
 
 # 流式逐 token 诊断日志开关（默认关）。开启后每个 chunk 都打印
 # chunk_type/content 等（仅供排障）。LLM 最终结果已由 LLMLogger.on_llm_end
@@ -219,6 +220,10 @@ def _patch_agent_streaming(agent):
             """替代 factory._execute_model_async: 用 astream + config 实现流式回调。"""
             from langchain.agents.middleware.types import ModelResponse
 
+            SYLogger.warning(
+                f"[STREAM-DEBUG] _patched_execute_model_async ENTERED | "
+                f"messages={len(request.messages)} 条 | "
+                f"has_system={bool(request.system_message)}")
             model_, effective_response_format = _get_bound_model(request)
             messages = request.messages
 
@@ -558,12 +563,24 @@ class DeepAgent:
             if _STREAM_DEBUG:
                 print(
                     f"[DeepAgent] chat() starting stream, message={repr(message[:80])}", flush=True)
+            SYLogger.warning(
+                f"[STREAM-DEBUG] agent.astream ABOUT TO START | "
+                f"thread={getattr(self, 'thread_id', '?')} | "
+                f"checkpoint_type={type(getattr(self, 'agent', None).__class__).__name__}")
+            _astream_chunk_count = 0
             async for chunk in self._astream_with_retry(
                 input_state,
                 max_retries=3,
                 base_delay=1.0,
             ):
                 # 🔑 逐 token 诊断日志：仅在 DEEP_AGENT_STREAM_DEBUG=true 时打印
+                _astream_chunk_count += 1
+                if _astream_chunk_count == 1:
+                    _first = chunk
+                    _first_type = type(chunk).__name__
+                    SYLogger.warning(
+                        f"[STREAM-DEBUG] agent.astream FIRST CHUNK received | "
+                        f"type={_first_type}")
                 if _STREAM_DEBUG:
                     _chunk_len = len(chunk) if isinstance(
                         chunk, tuple) else '?'
@@ -1011,6 +1028,11 @@ class DeepAgent:
                 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)
 
+            SYLogger.warning(
+                f"[STREAM-DEBUG] FOR LOOP ENDED | _astream_chunk_count={_astream_chunk_count} | "
+                f"stream_step={stream_step} | ai_text_len={len(ai_text_content)} | "
+                f"tool_calls={len(current_tool_calls)}")
+
             # 空响应检测：模型被调用但没有产出任何文本。
             # 🔑 治本修复：纯空响应（无文本且无工具调用，常见于用户派生 key 被网关拒、
             # 网关返回空壳 AIMessage 而非异常）不再静默只打 warning —— 把它翻译成

sycommon_python_lib-0.2.7a46/src/sycommon/agent/reasoning_content_patch.py

@@ -0,0 +1,88 @@
+"""langchain_openai reasoning_content / reasoning 字段提取补丁。
+
+根因：
+  langchain_openai 1.3.5 的 ChatOpenAI 只针对官方 OpenAI 规范，源码
+  (base.py:7) 明确声明：第三方 provider 的非标准字段（reasoning_content /
+  reasoning_details）**不解析**。思考型模型（Qwen3.5 的 reasoning、
+  LongCat-2.0 的 reasoning_content、DeepSeek-R1 等）把推理过程放在这些字段，
+  被 _convert_delta_to_message_chunk（流式 chunk）/ _convert_dict_to_message
+  （非流式整包）直接丢弃。
+
+  deep_agent 的空响应判定（deep_agent.py:806-813, 1022）依赖
+  reasoning_content：模型把内容全放进 reasoning 字段时，content 为空，
+  langchain 又把 reasoning 字段丢了 → deep_agent 拿到既无 content 又无
+  reasoning_content 的空 AIMessage → 误判「空响应」触发三级降级，
+  最终给用户空气泡。
+
+修复：
+  wrap 上述两个转换函数，把 delta/message 里的 reasoning_content / reasoning
+  捞进 message.additional_kwargs["reasoning_content"]（按字符串累加）。
+  AIMessageChunk 累加（+）时会自动拼接同名字符串，deep_agent 既有逻辑
+  (additional_kwargs.get("reasoning_content")) 即可正常读取，无需改 deep_agent。
+
+  填 additional_kwargs 而非 content：reasoning 是推理过程，不应混进正文
+  content（否则会直接展示给用户 / 喂给工具解析）。deep_agent 已有专门分支
+  把它作为 reasoning 事件单独 yield（带 data["reasoning"]=True）。
+
+等 langchain 官方支持 reasoning_content（>1.3.5）后删除本模块即可。
+"""
+from __future__ import annotations
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+# 不同 provider 的思考字段名：
+#   reasoning_content —— LongCat / DeepSeek-R1 / 智谱 GLM 等
+#   reasoning         —— 部分 vLLM 部署的 Qwen
+_REASONING_KEYS = ("reasoning_content", "reasoning")
+
+
+def _extract_reasoning(d) -> str:
+    """从 delta/message dict 里提取思考内容（字符串拼接，兼容 str/dict 两种值形态）。"""
+    if not isinstance(d, dict):
+        return ""
+    for k in _REASONING_KEYS:
+        v = d.get(k)
+        if isinstance(v, str) and v:
+            return v
+        if isinstance(v, dict):  # 个别 provider 包成 {"content": "..."}
+            inner = v.get("content") or v.get("text")
+            if isinstance(inner, str) and inner:
+                return inner
+    return ""
+
+
+try:
+    import langchain_openai.chat_models.base as _lc_oai_base
+
+    _orig_delta = _lc_oai_base._convert_delta_to_message_chunk
+    _orig_dict = _lc_oai_base._convert_dict_to_message
+
+    def _with_reasoning(msg, rc: str):
+        """把 reasoning 追加到 message.additional_kwargs（不改原 dict，新构造）。"""
+        ak = dict(getattr(msg, "additional_kwargs", None) or {})
+        existing = ak.get("reasoning_content", "")
+        ak["reasoning_content"] = (existing + rc) if existing else rc
+        msg.additional_kwargs = ak
+        return msg
+
+    def _patched_convert_delta(_dict, default_class):
+        msg = _orig_delta(_dict, default_class)
+        rc = _extract_reasoning(_dict)
+        return _with_reasoning(msg, rc) if rc else msg
+
+    def _patched_convert_dict(_dict):
+        msg = _orig_dict(_dict)
+        rc = _extract_reasoning(_dict)
+        return _with_reasoning(msg, rc) if rc else msg
+
+    _lc_oai_base._convert_delta_to_message_chunk = _patched_convert_delta
+    _lc_oai_base._convert_dict_to_message = _patched_convert_dict
+    logger.info(
+        "[ReasoningContentPatch] 已 wrap _convert_delta_to_message_chunk / "
+        "_convert_dict_to_message，提取 reasoning_content/reasoning 字段")
+except ImportError:
+    logger.debug("[ReasoningContentPatch] langchain_openai 不可用，跳过补丁")
+except Exception as _patch_err:  # pragma: no cover
+    logger.warning(f"[ReasoningContentPatch] 补丁应用失败: {_patch_err}")

{sycommon_python_lib-0.2.7a44 → sycommon_python_lib-0.2.7a46}/src/sycommon/agent/sandbox/file_ops.py

@@ -41,11 +41,10 @@ if TYPE_CHECKING:
 # 沙箱 API 路径前缀
 SANDBOX_API_PREFIX = "/v1/sandbox"
 
-# 下载/读取的文件大小预检上限（OOM 兜底，env 可调）。
-# adownload_files 整包读 + base64 解码，agent 调 download 工具读大文件会把全量拉进内存；
-# aread 有行数 limit 但无字节上限。下载/读取前先 astat 拿 size，超限返回 error 让 agent
-# 改用 head/grep/offset+limit 读。astat 异常 fail-open（warning 后继续，避免额外 RPC 失败阻断）。
-MAX_DOWNLOAD_BYTES = int(os.environ.get("SANDBOX_DOWNLOAD_MAX_BYTES", 100 * 1024 * 1024))
+# aread 读取的文件大小预检上限（OOM 兜底，env 可调）。
+# aread 走 /v1/sandbox/read，服务端另有 500KiB 截断（_READ_MAX_OUTPUT_BYTES），客户端 10MB
+# 是早死早超生的预检，防 agent 把大文件读进 LLM 上下文。astat 异常 fail-open。
+# 注：文件搬运（下载/分享/同步）已全部改走流式 adownload_to_file，无大小闸。
 MAX_READ_BYTES = int(os.environ.get("SANDBOX_READ_MAX_BYTES", 10 * 1024 * 1024))
 
 

{sycommon_python_lib-0.2.7a44 → sycommon_python_lib-0.2.7a46}/src/sycommon/agent/sandbox/http_sandbox_backend.py

@@ -15,11 +15,48 @@ import sys
 import tempfile
 import threading
 import requests
+from dataclasses import dataclass
 from pathlib import Path, PurePosixPath
 from typing import Optional, List
 
 import aiohttp
 
+
+def _run_coro_sync(coro):
+    """在当前线程同步跑一个 coroutine（供同步方法调用异步实现）。
+
+    已在事件循环里则新起线程跑（避免嵌套 loop）；否则 new_event_loop 跑。
+    注意：coro 必须是「在任意线程新 loop 里都能跑」的——不要捕获外层 loop。
+    """
+    def _run_in_fresh_loop(c):
+        loop = asyncio.new_event_loop()
+        try:
+            return loop.run_until_complete(c)
+        finally:
+            loop.close()
+
+    try:
+        asyncio.get_running_loop()
+        in_loop = True
+    except RuntimeError:
+        in_loop = False
+
+    if in_loop:
+        import concurrent.futures
+        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as ex:
+            return ex.submit(_run_in_fresh_loop, coro).result()
+    return _run_in_fresh_loop(coro)
+
+
+@dataclass
+class FileDownloadResult:
+    """流式下载结果（adownload_to_file 返回）。不含 content bytes——文件已落盘到 dest。"""
+    path: str
+    dest: Optional[str] = None
+    size: int = 0
+    error: Optional[str] = None
+
+
 from sycommon.logging.kafka_log import SYLogger
 from sycommon.agent.sandbox.file_ops import FileOperationsMixin, SANDBOX_API_PREFIX
 
@@ -29,6 +66,9 @@ from deepagents.backends.protocol import (
     FileDownloadResponse,
     FileUploadResponse,
 )
+# FileDownloadResponse: 框架兼容（deepagents SkillsMiddleware/MemoryMiddleware 内部调
+# backend.adownload_files 批量下载 SKILL.md/memory，需此类型）。流式下载用 FileDownloadResult。
+
 
 # SSL 上下文
 try:
@@ -44,6 +84,28 @@ _SKILL_PATH_RE = re.compile(
 )
 
 
+def _extract_sandbox_error_code(body: str) -> Optional[str]:
+    """从沙箱错误响应体里提取规范 error 码（如 "file_not_found"）。
+
+    沙箱 4xx 错误体形如 {"error": "file_not_found", ...}。deepagents 的
+    MemoryMiddleware/SkillsMiddleware 约定 response.error == "file_not_found"
+    时视为「缺失文件正常跳过」；其它值才 raise。故本函数把 body 里的 error
+    字段原码提取出来，透传给上层；解析失败返回 None（调用方回退到整串）。
+    """
+    if not body:
+        return None
+    try:
+        import json as _json
+        obj = _json.loads(body)
+        if isinstance(obj, dict):
+            err = obj.get("error")
+            if isinstance(err, str) and err:
+                return err
+    except Exception:
+        pass
+    return None
+
+
 def _read_file_safe(path: str) -> bytes:
     with open(path, "rb") as f:
         return f.read()
@@ -1174,72 +1236,113 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                         path=path, error=str(ex)))
             return results
 
-    def download_files(self, paths: List[str]) -> List[FileDownloadResponse]:
-        """下载多个文件"""
-        results = []
-        for path in paths:
+    # 流式下载块大小（与服务端 _STREAM_CHUNK 对齐）。客户端按此尺寸从 HTTP 响应流读块、
+    # 写盘，内存峰值 ≈ 单块，与文件总大小无关。替代旧整包 download_files（base64 全量进内存）。
+    _STREAM_CHUNK = int(os.environ.get("SANDBOX_STREAM_CHUNK", 1024 * 1024))
+
+    async def _download_stream_to_file(self, path: str, dest: str, *, timeout: int = None) -> "FileDownloadResult":
+        """流式下载单个沙箱文件到本地 dest（内部实现，含 failover）。
+
+        打 POST /v1/sandbox/download/stream，按 _STREAM_CHUNK 流式写盘，不进进程大内存。
+        失败时（瞬时网络抖动）原地重试一次，再切实例一次，策略对齐 _post_async_with_failover。
+        """
+        headers = self._build_headers()
+        http_timeout = (timeout or self._timeout) + 30
+        timeout_obj = aiohttp.ClientTimeout(total=http_timeout)
+
+        async def _do(base_url: str) -> "FileDownloadResult":
+            session = await self._get_async_session()
+            u = f"{base_url}{SANDBOX_API_PREFIX}/download/stream"
+            async with session.post(u, json={"path": path, "user_id": self._user_id},
+                                    headers=headers, timeout=timeout_obj) as resp:
+                if resp.status >= 400:
+                    text = await resp.text()
+                    # 🔑 对齐 deepagents 约定：沙箱错误体里的 error 码必须原样透传
+                    # （如 "file_not_found"）。MemoryMiddleware/SkillsMiddleware 据此
+                    # 判断「缺失文件 → 正常跳过 continue」；若包成 "HTTP 404: {...}"
+                    # 整串，框架匹配不上就会 raise ValueError，被上层当沙箱故障恢复 3 次，
+                    # 耗尽后 graph 产 0 chunk → 最终给用户「模型返回空响应」。
+                    _code = _extract_sandbox_error_code(text)
+                    return FileDownloadResult(
+                        path=path, error=_code or f"HTTP {resp.status}: {text[:200]}")
+                with open(dest, "wb") as f:
+                    async for chunk in resp.content.iter_chunked(self._STREAM_CHUNK):
+                        f.write(chunk)
+            return FileDownloadResult(path=path, dest=dest,
+                                      size=os.path.getsize(dest))
+
+        last_exc: Optional[Exception] = None
+        for attempt in range(2):
             try:
-                result = self._post_sync(
-                    f"{SANDBOX_API_PREFIX}/download",
-                    {"path": path, "user_id": self._user_id}
-                )
-                if result.get("error"):
-                    results.append(FileDownloadResponse(
-                        path=path,
-                        error=result["error"]
-                    ))
-                else:
-                    content = base64.b64decode(result["content"])
-                    results.append(FileDownloadResponse(
-                        path=path, content=content))
-            except Exception as e:
-                results.append(FileDownloadResponse(path=path, error=str(e)))
-        return results
+                return await _do(self._base_url)
+            except (aiohttp.ClientError, asyncio.TimeoutError, OSError) as e:
+                last_exc = e
+                SYLogger.warning(
+                    f"[Sandbox] 流式下载失败 (尝试 {attempt+1}/2): "
+                    f"{self._base_url} path={path} - {e}")
+                if attempt == 0:
+                    await asyncio.sleep(1)
+        switched = await asyncio.to_thread(self._refresh_from_nacos_and_switch_sync)
+        if switched:
+            try:
+                return await _do(self._base_url)
+            except (aiohttp.ClientError, asyncio.TimeoutError, OSError) as e:
+                last_exc = e
+                SYLogger.warning(f"[Sandbox] 切实例后流式下载仍失败: {self._base_url} - {e}")
+        try:
+            os.unlink(dest)
+        except OSError:
+            pass
+        return FileDownloadResult(path=path, error=f"流式下载失败: {last_exc}")
 
-    async def adownload_files(self, paths: List[str], *, timeout: int = None) -> List[FileDownloadResponse]:
-        """异步下载多个文件（真正的异步实现）
+    async def adownload_to_file(self, path: str, dest: str, *, timeout: int = None) -> "FileDownloadResult":
+        """流式下载沙箱文件到本地 dest 路径（推荐用法，内存峰值≈单块）。
 
-        🔑 OOM 兜底：每个文件下载前先 astat 拿 size（只查 size 不读内容），
-        超 MAX_DOWNLOAD_BYTES 直接返回 error，避免整包读 + base64 解码把全量拉进内存。
-        astat 异常 fail-open（warning 后继续下载）。
+        Args:
+            path: 沙箱内文件路径
+            dest: 本地目标文件路径（调用方负责清理；建议用 tempfile）
+            timeout: 超时秒数
+
+        Returns:
+            FileDownloadResult(path, dest, size, error)。error 非 None 即失败。
         """
-        from sycommon.agent.sandbox.file_ops import MAX_DOWNLOAD_BYTES
-        results = []
-        for path in paths:
+        return await self._download_stream_to_file(path, dest, timeout=timeout)
+
+    # ---- 框架兼容：deepagents SkillsMiddleware/MemoryMiddleware 内部调
+    # backend.adownload_files(paths) 批量下载 SKILL.md/memory（第三方代码，无法改）。
+    # 这里保留 adownload_files/download_files 签名，内部走流式下载到临时文件再读 bytes，
+    # 内存安全。业务代码（get_share_url/minio_sync 等）应优先用 adownload_to_file 不读回。
+    async def adownload_files(self, paths: List[str], *, timeout: int = None) -> List[FileDownloadResponse]:
+        """批量下载（框架兼容）。内部流式落临时文件再读 bytes。"""
+        results: List[FileDownloadResponse] = []
+        for p in paths:
+            import tempfile as _tf
+            with _tf.NamedTemporaryFile(delete=False) as _tmp:
+                tmp_path = _tmp.name
             try:
-                # 大小预检：超限直接拒绝，不下载
-                try:
-                    st = await self.astat(path=path)
-                    if st and not getattr(st, "error", None) and getattr(st, "exists", False):
-                        fsize = getattr(st, "size", 0) or 0
-                        if fsize > MAX_DOWNLOAD_BYTES:
-                            cap_mb = MAX_DOWNLOAD_BYTES // (1024 * 1024)
-                            SYLogger.warning(f"[Sandbox] 文件过大拒绝下载: {path}, size={fsize}")
-                            results.append(FileDownloadResponse(
-                                path=path,
-                                error=f"file too large ({fsize // (1024*1024)}MB > {cap_mb}MB)"))
-                            continue
-                except Exception as se:
-                    SYLogger.warning(f"[Sandbox] astat 预检失败(继续下载): {se}")
-
-                result = await self._post_async_with_failover(
-                    f"{SANDBOX_API_PREFIX}/download",
-                    {"path": path, "user_id": self._user_id},
-                    timeout=timeout
-                )
-                if result.get("error"):
-                    results.append(FileDownloadResponse(
-                        path=path,
-                        error=result["error"]
-                    ))
+                r = await self.adownload_to_file(p, tmp_path, timeout=timeout)
+                if r.error:
+                    results.append(FileDownloadResponse(path=p, error=r.error))
                 else:
-                    content = base64.b64decode(result["content"])
-                    results.append(FileDownloadResponse(
-                        path=path, content=content))
+                    with open(tmp_path, "rb") as _f:
+                        results.append(FileDownloadResponse(path=p, content=_f.read()))
             except Exception as e:
-                results.append(FileDownloadResponse(path=path, error=str(e)))
+                results.append(FileDownloadResponse(path=p, error=str(e)))
+            finally:
+                try:
+                    os.unlink(tmp_path)
+                except OSError:
+                    pass
         return results
 
+    def download_files(self, paths: List[str]) -> List[FileDownloadResponse]:
+        """批量下载（同步包装，框架兼容）。"""
+        return _run_coro_sync(self.adownload_files(paths))
+
+    def download_to_file(self, path: str, dest: str, *, timeout: int = None) -> "FileDownloadResult":
+        """流式下载（同步包装）。在线程池独立 loop 里跑 adownload_to_file。"""
+        return _run_coro_sync(self.adownload_to_file(path, dest, timeout=timeout))
+
     # ============== 目录同步 ==============
 
     def _sync_sync(self) -> dict:
@@ -1552,18 +1655,26 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 continue
             file_path = file_info["path"]
             try:
-                download_result = self._post_sync(
-                    f"{SANDBOX_API_PREFIX}/download",
-                    {"path": file_path, "user_id": self._user_id}
-                )
-                if download_result.get("error"):
-                    failed_count += 1
-                    errors.append(
-                        {"path": file_path, "error": download_result["error"]})
-                else:
-                    content = base64.b64decode(download_result["content"])
-                    files_to_sync.append((file_path, content))
-                    success_count += 1
+                # 流式下载到临时文件再读 bytes（旧实现走整包 /download base64 全量进内存）。
+                # 同步上下文：在线程池里跑 adownload_to_file。文件通常为技能/memory/历史小文件，
+                # 落盘读回可接受；大文件也不爆内存。
+                import tempfile as _tf
+                with _tf.NamedTemporaryFile(delete=False) as _tmp:
+                    tmp_path = _tmp.name
+                try:
+                    r = _run_coro_sync(self.adownload_to_file(file_path, tmp_path))
+                    if r.error:
+                        failed_count += 1
+                        errors.append({"path": file_path, "error": r.error})
+                    else:
+                        with open(tmp_path, "rb") as _f:
+                            files_to_sync.append((file_path, _f.read()))
+                        success_count += 1
+                finally:
+                    try:
+                        os.unlink(tmp_path)
+                    except OSError:
+                        pass
             except Exception as e:
                 failed_count += 1
                 errors.append({"path": file_path, "error": str(e)})

{sycommon_python_lib-0.2.7a44 → sycommon_python_lib-0.2.7a46}/src/sycommon/agent/sandbox/minio_sync.py

@@ -196,6 +196,44 @@ class MinioSyncService(metaclass=SingletonMeta):
             SYLogger.error(f"[MinIO] Upload failed: {object_key}, error={e}")
             return False
 
+    def upload_stream(self, object_key: str, file_obj, length: int,
+                      content_type: str = "application/octet-stream") -> bool:
+        """从 file-like 对象流式分片上传（大文件专用，内存峰值≈5MB）。
+
+        MinIO put_object(length=size, part_size=0) 自动按 5MB 分片读 file_obj，
+        不一次性 read 全文件。已验证 50/100/200MB 上传内存峰值恒定 5MB。
+
+        Args:
+            object_key: MinIO 对象 key
+            file_obj: 有 read() 的二进制文件对象（如 open(path,'rb')）
+            length: 文件总字节数（必传，决定分片数）
+            content_type: MIME
+        """
+        if not self._client:
+            return False
+        try:
+            self._client.put_object(
+                bucket_name=self._bucket,
+                object_name=object_key,
+                data=file_obj,
+                length=length,
+                content_type=content_type,
+                # part_size=0 → minio 按 length 自动算 5MB 分片
+            )
+            SYLogger.info(
+                f"[MinIO] Stream upload success: {object_key}, size={length}")
+            return True
+        except Exception as e:
+            SYLogger.error(f"[MinIO] Stream upload failed: {object_key}, error={e}")
+            return False
+
+    async def aupload_stream(self, object_key: str, file_obj, length: int,
+                             content_type: str = "application/octet-stream") -> bool:
+        """异步流式分片上传"""
+        return await asyncio.to_thread(
+            self.upload_stream, object_key, file_obj, length, content_type)
+
+
     async def aupload_bytes(self, object_key: str, content: bytes,
                             content_type: str = "application/octet-stream") -> bool:
         """异步上传文件到 MinIO"""
@@ -606,30 +644,49 @@ class MinioSyncService(metaclass=SingletonMeta):
 
     async def _sync_one(self, sandbox_backend, fp: str,
                         existing_objects: dict, prefix: str) -> bool:
-        """同步单个文件：下载 + 上传，成功返回 True"""
+        """同步单个文件：流式下载到临时文件 + 流式上传 MinIO，成功返回 True。
+
+        内存峰值≈5MB（沙箱流式落盘 + MinIO 5MB 分片），与文件大小无关。
+        替代旧实现（adownload_files 整包读 + upload_bytes 全量进内存）。
+        """
+        import tempfile as _tf
+        tmp_path = None
         try:
-            results = await sandbox_backend.adownload_files([f"/{fp}"])
-            if not results or results[0].error or not results[0].content:
-                error = results[0].error if results else "unknown"
-                SYLogger.warning(f"[MinIO] 下载沙箱文件失败: {fp}, error={error}")
+            # MinIO 已有且 size 相同时，用 astat 的 size 先判跳过（省一次下载）
+            st = await sandbox_backend.astat(path=f"/{fp}")
+            if not st or getattr(st, "error", None) or not getattr(st, "exists", False):
+                SYLogger.warning(f"[MinIO] astat 沙箱文件失败/不存在: {fp}")
                 return False
-
-            content = results[0].content
-
-            # 如果 MinIO 已有且 size 相同，跳过
-            if fp in existing_objects and existing_objects[fp].size == len(content):
+            fsize = getattr(st, "size", 0) or 0
+            if fp in existing_objects and existing_objects[fp].size == fsize:
                 return False
 
             mime_type, _ = mimetypes.guess_type(fp)
             object_key = f"{prefix}{fp}"
 
-            return await self.aupload_bytes(
-                object_key, content,
-                content_type=mime_type or "application/octet-stream",
-            )
+            # 流式下载到临时文件
+            with _tf.NamedTemporaryFile(delete=False) as tmp:
+                tmp_path = tmp.name
+            r = await sandbox_backend.adownload_to_file(f"/{fp}", tmp_path)
+            if r.error or r.size == 0:
+                SYLogger.warning(f"[MinIO] 流式下载沙箱文件失败: {fp}, error={r.error}")
+                return False
+            # 流式分片上传 MinIO（open 后由 minio 内部 5MB 分片读，不进大内存）
+            with open(tmp_path, "rb") as f:
+                return await self.aupload_stream(
+                    object_key, f, r.size,
+                    content_type=mime_type or "application/octet-stream",
+                )
         except Exception as e:
             SYLogger.warning(f"[MinIO] 同步文件异常: {fp}, error={e}")
             return False
+        finally:
+            if tmp_path:
+                try:
+                    os.unlink(tmp_path)
+                except OSError:
+                    pass
+
 
     # ============== 用户上传文件直推（fire-and-forget 后台）==============
     # 用户刚传上来的文件优先落 MinIO：不等会话结束扫描，免得沙箱中途崩溃丢文件。