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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.5a12
+Version: 0.2.5a13
 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.5a13}/pyproject.toml

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

{sycommon_python_lib-0.2.5a12 → sycommon_python_lib-0.2.5a13}/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.5a13}/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.5a13}/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,8 +113,8 @@ 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
@@ -725,129 +726,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]: