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

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

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

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

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

{sycommon_python_lib-0.2.5a12 → sycommon_python_lib-0.2.5a14}/src/sycommon/agent/deep_agent.py

@@ -49,7 +49,6 @@ from sycommon.llm.get_llm import get_llm
 from sycommon.agent.sandbox.http_sandbox_backend import HTTPSandboxBackend
 from sycommon.agent.sandbox.sandbox_recovery import SandboxRecoveryManager
 from sycommon.agent.chat_events import ChatEvent, ChatEventBuilder, DEFAULT_AGENT_NAME
-from sycommon.middleware.background_execution import BackgroundExecutionMiddleware
 from sycommon.middleware.token_tracking import TokenTrackingMiddleware
 from sycommon.middleware.tool_result_truncation import ToolResultTruncationMiddleware
 from deepagents.middleware.summarization import create_summarization_tool_middleware  # noqa: F401 保留 re-export
@@ -118,9 +117,6 @@ class AgentConfig(BaseModel):
     # 调试模式
     debug: bool = False
 
-    # 后台执行超时（秒）
-    background_timeout: int = 600
-
     class Config:
         arbitrary_types_allowed = True
 
@@ -143,12 +139,8 @@ class DeepAgent:
         self.recovery_manager = recovery_manager
 
     async def cleanup(self):
-        """清理资源：终止该用户的所有后台进程"""
-        if self.sandbox_backend:
-            try:
-                await self.sandbox_backend.akill_all_processes()
-            except Exception as e:
-                SYLogger.warning(f"[DeepAgent] 清理后台进程失败: {e}")
+        """清理资源"""
+        pass
 
     async def chat(
         self,
@@ -653,7 +645,6 @@ async def create_deep_agent(
         "system_prompt": config.system_prompt,
         "debug": config.debug,
         "middleware": [
-            BackgroundExecutionMiddleware(backend=sandbox_backend),
             ToolResultTruncationMiddleware(),
             TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
             summarization_mw,

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

@@ -42,7 +42,6 @@ from sycommon.agent.sandbox.http_sandbox_backend import HTTPSandboxBackend
 from sycommon.tools.env import get_env_var
 from sycommon.agent.sandbox.sandbox_recovery import SandboxRecoveryManager
 from sycommon.agent.chat_events import ChatEvent, ChatEventBuilder, DEFAULT_AGENT_NAME
-from sycommon.middleware.background_execution import BackgroundExecutionMiddleware
 from sycommon.middleware.token_tracking import TokenTrackingMiddleware
 from sycommon.middleware.tool_result_truncation import ToolResultTruncationMiddleware
 from deepagents.middleware.summarization import create_summarization_tool_middleware  # noqa: F401 保留 re-export
@@ -109,42 +108,6 @@ class TeamMember(BaseModel):
 - 认真完成分配给你的任务
 - 与团队成员保持良好协作
 - 用中文回答问题
-
-## 重要约束 - 沙箱执行环境
-
-### 后台执行工具
-
-沙箱提供了专门的后台执行工具，用于管理长时间运行的服务：
-
-- **execute_background(command, timeout=600)**: 在后台启动命令（不阻塞），返回 process_id
-- **check_process(process_id)**: 检查后台进程的状态
-- **kill_process(process_id)**: 终止后台进程
-
-### 启动和测试服务的正确方式
-
-当需要启动长时间运行的服务（如 FastAPI、数据库）时：
-
-```python
-# 1. 后台启动服务
-result = execute_background(command="uvicorn main:app --host 0.0.0.0 --port 8000")
-process_id = result["process_id"]
-
-# 2. 等待服务启动
-execute(command="sleep 3")
-
-# 3. 测试服务
-execute(command="curl http://localhost:8000/health")
-
-# 4. 完成后终止服务（重要！）
-kill_process(process_id=process_id)
-```
-
-### 关键规则
-
-1. **启动服务必须使用 execute_background** - 使用 execute 启动服务会超时
-2. **记住 process_id** - 每次启动服务都会返回新的 process_id，需要保存用于后续操作
-3. **测试完成后必须 kill_process** - 避免资源浪费
-4. **使用 check_process 检查状态** - 可以查看服务是否还在运行
 """
 
     class Config:
@@ -228,12 +191,8 @@ class MultiAgentTeam:
         self.recovery_manager = recovery_manager
 
     async def cleanup(self):
-        """清理资源：终止该用户的所有后台进程"""
-        if self.sandbox_backend:
-            try:
-                await self.sandbox_backend.akill_all_processes()
-            except Exception as e:
-                SYLogger.warning(f"[MultiAgentTeam] 清理后台进程失败: {e}")
+        """清理资源"""
+        pass
 
     async def chat(
         self,
@@ -590,7 +549,6 @@ async def create_multi_agent_team(
 
     summarization_mw = build_summarization_middleware(model, config.model_name, sandbox_backend)
     middleware = [
-        BackgroundExecutionMiddleware(backend=sandbox_backend),
         ToolResultTruncationMiddleware(),
         TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
         summarization_mw,
@@ -647,7 +605,6 @@ async def create_multi_agent_team(
         debug=config.debug,
         name=coord_name,
         middleware=[
-            BackgroundExecutionMiddleware(backend=sandbox_backend),
             ToolResultTruncationMiddleware(),
             TokenTrackingMiddleware(model_name=config.model_name, user_id=user_id),
             coord_summarization_mw,

{sycommon_python_lib-0.2.5a12 → sycommon_python_lib-0.2.5a14}/src/sycommon/agent/sandbox/http_sandbox_backend.py

@@ -90,6 +90,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         auto_sync: bool = False,
         nacos_service_name: str = None,
         nacos_group: str = "DEFAULT_GROUP",
+        token: str = None,
     ):
         """
         初始化 HTTP 沙箱后端
@@ -112,13 +113,17 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         self._workspace_verified = False
         self._local_mode: Optional[bool] = None
 
-        # Token authentication
-        self._token = os.environ.get("SANDBOX_TOKEN", "")
+        # Token authentication: instance-level > env var
+        self._token = token if token is not None else os.environ.get("SANDBOX_TOKEN", "")
 
         # Nacos 配置（用于故障转移）
         self._nacos_service_name = nacos_service_name
         self._nacos_group = nacos_group
 
+        # 共享异步 HTTP 会话（连接池复用，惰性初始化）
+        self._async_session: Optional[aiohttp.ClientSession] = None
+        self._session_loop_id: Optional[int] = None  # track which loop created the session
+
         # 生成 ID
         self._id = self._base_url.replace(
             "http://", ""
@@ -130,6 +135,55 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             "/", "-"
         )
 
+    async def _get_async_session(self) -> aiohttp.ClientSession:
+        """获取或创建共享的 aiohttp ClientSession（连接池复用）
+
+        Handles the case where the backend was created in a different thread
+        (e.g. via asyncio.to_thread) by detecting loop mismatch and resetting.
+        """
+        try:
+            current_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            current_loop = None
+
+        # If session was created on a different event loop, discard it
+        if self._async_session is not None and self._session_loop_id != id(current_loop):
+            try:
+                self._async_session.close()
+            except Exception:
+                pass
+            self._async_session = None
+
+        if self._async_session is None or self._async_session.closed:
+            connector = aiohttp.TCPConnector(
+                ssl=_SSL_CONTEXT,
+                limit=10,
+                limit_per_host=10,
+                keepalive_timeout=30,
+                enable_cleanup_closed=True,
+            )
+            self._async_session = aiohttp.ClientSession(connector=connector)
+            self._session_loop_id = id(current_loop)
+        return self._async_session
+
+    async def acleanup(self):
+        """关闭共享的异步 HTTP 会话，释放连接池资源"""
+        if self._async_session and not self._async_session.closed:
+            await self._async_session.close()
+            self._async_session = None
+
+    def cleanup(self):
+        """同步方式关闭共享会话（供非 async 上下文使用）"""
+        if self._async_session and not self._async_session.closed:
+            try:
+                loop = asyncio.get_running_loop()
+                loop.create_task(self._async_session.close())
+            except RuntimeError:
+                loop = asyncio.new_event_loop()
+                loop.run_until_complete(self._async_session.close())
+                loop.close()
+            self._async_session = None
+
     @classmethod
     def from_nacos(
         cls,
@@ -360,10 +414,11 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 SYLogger.warning(f"[Sandbox] 请求失败 (尝试 {attempt + 1}/{max_retries}): {self._base_url} - {e}")
 
                 if attempt < max_retries - 1:
+                    backoff = 2 ** attempt
                     switched = self._refresh_from_nacos_and_switch_sync()
                     if not switched:
                         import time
-                        time.sleep(1)
+                        time.sleep(backoff)
                 else:
                     raise RuntimeError(f"沙箱服务不可用: {e}")
 
@@ -376,38 +431,32 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
     # ============== 内部方法 - 异步版本 ==============
 
     async def _post_async(self, endpoint: str, data: dict, timeout: int = None) -> dict:
-        """异步 POST 请求（每次创建独立 session，避免跨 Task 共享导致超时上下文错误）"""
+        """异步 POST 请求（使用共享连接池）"""
         actual_timeout = timeout if timeout is not None else self._timeout
         if "/execute" in endpoint:
             http_timeout = actual_timeout + 60
         else:
             http_timeout = actual_timeout + 30
 
-        trace_id = SYLogger.get_trace_id()
-        headers = {"Content-Type": "application/json"}
-        if trace_id:
-            headers["x-traceid-header"] = str(trace_id)
-        if self._token:
-            headers["X-Sandbox-Token"] = self._token
+        headers = self._build_headers()
 
         url = f"{self._base_url}{endpoint}"
         SYLogger.info(f"[Sandbox] Async POST 请求开始: {url}, timeout={http_timeout}s")
 
         timeout_obj = aiohttp.ClientTimeout(total=http_timeout)
-        connector = aiohttp.TCPConnector(ssl=_SSL_CONTEXT)
-        async with aiohttp.ClientSession(connector=connector) as session:
-            async with session.post(url, json=data, headers=headers, timeout=timeout_obj) as resp:
-                SYLogger.info(f"[Sandbox] Async POST 响应状态码: {resp.status}")
-                if resp.status >= 400:
-                    text = await resp.text()
-                    SYLogger.error(f"[Sandbox] HTTP 错误 {resp.status}: {text}")
-                    resp.raise_for_status()
-                result = await resp.json()
-                SYLogger.info(f"[Sandbox] Async POST 成功: {url}")
-                return result
+        session = await self._get_async_session()
+        async with session.post(url, json=data, headers=headers, timeout=timeout_obj) as resp:
+            SYLogger.info(f"[Sandbox] Async POST 响应状态码: {resp.status}")
+            if resp.status >= 400:
+                text = await resp.text()
+                SYLogger.error(f"[Sandbox] HTTP 错误 {resp.status}: {text}")
+                resp.raise_for_status()
+            result = await resp.json()
+            SYLogger.info(f"[Sandbox] Async POST 成功: {url}")
+            return result
 
     async def _post_async_with_failover(self, endpoint: str, data: dict, timeout: int = None) -> dict:
-        """带故障转移的异步 POST 请求"""
+        """带故障转移和指数退避的异步 POST 请求"""
         max_retries = 3
 
         for attempt in range(max_retries):
@@ -417,10 +466,12 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 SYLogger.warning(f"[Sandbox] Async 请求失败 (尝试 {attempt + 1}/{max_retries}): {self._base_url} - {e}")
 
                 if attempt < max_retries - 1:
+                    # 指数退避: 1s, 2s
+                    backoff = 2 ** attempt
                     # 尝试故障转移
                     switched = await asyncio.to_thread(self._refresh_from_nacos_and_switch_sync)
                     if not switched:
-                        await asyncio.sleep(1)
+                        await asyncio.sleep(backoff)
                 else:
                     raise RuntimeError(f"沙箱服务不可用: {e}")
 
@@ -489,20 +540,19 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             SYLogger.info(f"[Sandbox] 使用环境变量 SANDBOX_WORKSPACE={env_workspace}")
             return self._workspace_root
 
-        # 从沙箱服务端 health 接口获取（aiohttp 异步）
+        # 从沙箱服务端 health 接口获取（使用共享连接池）
         try:
             url = f"{self._base_url}{SANDBOX_API_PREFIX}/health"
-            connector = aiohttp.TCPConnector(ssl=_SSL_CONTEXT)
             timeout_obj = aiohttp.ClientTimeout(total=10)
-            async with aiohttp.ClientSession(connector=connector) as session:
-                async with session.get(url, timeout=timeout_obj) as resp:
-                    if resp.status == 200:
-                        data = await resp.json()
-                        workspace = data.get("workspace", "")
-                        if workspace:
-                            self._workspace_root = workspace
-                            SYLogger.info(f"[Sandbox] 从沙箱服务端获取 WORKSPACE_ROOT={workspace}")
-                            return self._workspace_root
+            session = await self._get_async_session()
+            async with session.get(url, timeout=timeout_obj) as resp:
+                if resp.status == 200:
+                    data = await resp.json()
+                    workspace = data.get("workspace", "")
+                    if workspace:
+                        self._workspace_root = workspace
+                        SYLogger.info(f"[Sandbox] 从沙箱服务端获取 WORKSPACE_ROOT={workspace}")
+                        return self._workspace_root
         except Exception as e:
             SYLogger.warning(f"[Sandbox] 异步获取沙箱 workspace 失败: {e}")
 
@@ -725,129 +775,6 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         SYLogger.info(f"[Sandbox] _upload_directory_async 完成: 成功={success_count}, 失败={failed_count}")
         return {"success": success_count, "failed": failed_count, "errors": errors}
 
-    # ============== 后台进程执行 ==============
-
-    def execute_background(self, command: str, *, timeout: int = 600) -> dict:
-        """后台执行 shell 命令（不阻塞，立即返回 process_id）"""
-        self._ensure_synced_sync()
-        SYLogger.info(f"[Sandbox] 后台执行: {command}")
-        try:
-            result = self._post_sync(f"{SANDBOX_API_PREFIX}/execute_background", {
-                "command": command.strip(),
-                "user_id": self._user_id,
-                "timeout": timeout
-            })
-            SYLogger.info(f"[Sandbox] 后台进程已启动: process_id={result['process_id']}")
-            return result
-        except Exception as e:
-            SYLogger.error(f"[Sandbox] 后台执行失败: {e}")
-            return {"process_id": None, "status": "error", "error": str(e)}
-
-    async def aexecute_stream(self, command: str, *, timeout: int = None):
-        """异步流式执行 shell 命令，yield SSE 事件字典
-
-        每个 yield 的格式: {"type": "output"|"done"|"error", "data": ..., "exit_code": ...}
-        """
-        await self._ensure_synced_async()
-        actual_timeout = timeout if timeout is not None else self._timeout
-        url = f"{self._base_url}{SANDBOX_API_PREFIX}/execute_stream"
-        timeout_obj = aiohttp.ClientTimeout(total=actual_timeout + 60)
-        connector = aiohttp.TCPConnector(ssl=_SSL_CONTEXT)
-        async with aiohttp.ClientSession(connector=connector) as session:
-            async with session.post(url, json={
-                "command": command.strip(),
-                "user_id": self._user_id,
-                "timeout": actual_timeout
-            }, timeout=timeout_obj) as resp:
-                resp.raise_for_status()
-                buffer = ""
-                async for chunk in resp.content.iter_any():
-                    buffer += chunk.decode('utf-8', errors='replace')
-                    while "\n\n" in buffer:
-                        event_str, buffer = buffer.split("\n\n", 1)
-                        for line in event_str.strip().split("\n"):
-                            if line.startswith("data: "):
-                                import json
-                                yield json.loads(line[6:])
-
-    async def aexecute_background(self, command: str, *, timeout: int = None) -> dict:
-        """异步后台执行 shell 命令（服务端负责路径隔离）"""
-        await self._ensure_synced_async()
-        actual_timeout = timeout if timeout is not None else 600
-        SYLogger.info(f"[Sandbox] 异步后台执行: {command}")
-        try:
-            result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/execute_background", {
-                "command": command.strip(),
-                "user_id": self._user_id,
-                "timeout": actual_timeout
-            }, timeout=actual_timeout)
-            SYLogger.info(f"[Sandbox] 异步后台进程已启动: process_id={result['process_id']}")
-            return result
-        except Exception as e:
-            SYLogger.error(f"[Sandbox] 异步后台执行失败: {e}")
-            return {"process_id": None, "status": "error", "error": str(e)}
-
-    async def acheck_process(self, process_id: str, *, timeout: int = None) -> dict:
-        """异步检查后台进程状态"""
-        try:
-            result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/process_status", {
-                "process_id": process_id,
-                "user_id": self._user_id
-            }, timeout=timeout)
-            return result
-        except Exception as e:
-            SYLogger.error(f"[Sandbox] 异步检查进程失败: {e}")
-            return {"process_id": process_id, "status": "error", "error": str(e)}
-
-    async def akill_process(self, process_id: str, *, timeout: int = None) -> dict:
-        """异步终止后台进程"""
-        try:
-            result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/kill_process", {
-                "process_id": process_id,
-                "user_id": self._user_id
-            }, timeout=timeout)
-            SYLogger.info(f"[Sandbox] 异步进程终止: {process_id}, status={result['status']}")
-            return result
-        except Exception as e:
-            SYLogger.error(f"[Sandbox] 异步终止进程失败: {e}")
-            return {"process_id": process_id, "status": "error", "error": str(e)}
-
-    async def akill_all_processes(self, *, timeout: int = None) -> dict:
-        """异步终止该用户的所有后台进程"""
-        try:
-            result = await self._post_async_with_failover(
-                f"{SANDBOX_API_PREFIX}/kill_all_processes",
-                {"user_id": self._user_id},
-                timeout=timeout,
-            )
-            SYLogger.info(
-                f"[Sandbox] 批量终止进程: "
-                f"killed={result.get('killed_count', 0)}, "
-                f"already_completed={result.get('already_completed', 0)}"
-            )
-            return result
-        except Exception as e:
-            SYLogger.error(f"[Sandbox] 批量终止进程失败: {e}")
-            return {"killed_count": 0, "error": str(e)}
-
-    # ============== 端口转发 ==============
-
-    async def aport_forward(self, port: int, action: str = "list", *, timeout: int = None) -> dict:
-        """异步端口转发管理"""
-        return await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/port_forward", {
-            "port": port,
-            "user_id": self._user_id,
-            "action": action,
-        }, timeout=timeout)
-
-    async def awatch(self, path: str = "/", event_types: list = None, *, timeout: int = None) -> dict:
-        """异步查询文件变更"""
-        return await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/watch", {
-            "path": path,
-            "user_id": self._user_id,
-            "event_types": event_types,
-        }, timeout=timeout)
-
     # ============== 批量操作 ==============
 
     def upload_files(self, files: List[tuple[str, bytes]]) -> List[FileUploadResponse]:
@@ -1193,7 +1120,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                     failed_count += 1
                     errors.append({"path": sandbox_path, "error": str(e)})
 
-        max_workers = min(8, len(files_to_upload)) if files_to_upload else 1
+        max_workers = min(4, len(files_to_upload)) if files_to_upload else 1
         with ThreadPoolExecutor(max_workers=max_workers) as executor:
             futures = [
                 executor.submit(_upload_one, idx, sandbox_path, local_file)
@@ -1307,18 +1234,17 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             raise
 
     async def ahealth_check(self, timeout: int = 10) -> dict:
-        """异步健康检查"""
+        """异步健康检查（使用共享连接池）"""
         try:
             headers = self._build_headers()
             url = f"{self._base_url}{SANDBOX_API_PREFIX}/health"
             timeout_obj = aiohttp.ClientTimeout(total=timeout)
-            connector = aiohttp.TCPConnector(ssl=_SSL_CONTEXT)
-            async with aiohttp.ClientSession(connector=connector) as session:
-                async with session.get(url, headers=headers, timeout=timeout_obj) as resp:
-                    resp.raise_for_status()
-                    result = await resp.json()
-                    SYLogger.info(f"[Sandbox] 异步健康检查成功: {result}")
-                    return result
+            session = await self._get_async_session()
+            async with session.get(url, headers=headers, timeout=timeout_obj) as resp:
+                resp.raise_for_status()
+                result = await resp.json()
+                SYLogger.info(f"[Sandbox] 异步健康检查成功: {result}")
+                return result
         except Exception as e:
             SYLogger.error(f"[Sandbox] 异步健康检查失败: {e}")
             raise