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

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

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

{sycommon_python_lib-0.2.2a12 → sycommon_python_lib-0.2.2a13}/pyproject.toml

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

{sycommon_python_lib-0.2.2a12 → sycommon_python_lib-0.2.2a13}/src/sycommon/agent/sandbox/file_ops.py

@@ -196,7 +196,7 @@ class FileOperationsMixin:
             SYLogger.error(f"[Sandbox] 列出目录失败: {e}")
             return LsResult(error=str(e))
 
-    async def als(self: "HTTPSandboxBackend", path: str) -> LsResult:
+    async def als(self: "HTTPSandboxBackend", path: str, *, timeout: int = None) -> LsResult:
         """异步列出目录内容"""
         try:
             await self._ensure_synced_async()
@@ -204,7 +204,7 @@ class FileOperationsMixin:
             result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/ls", {
                 "path": path,
                 "user_id": self.user_id
-            })
+            }, timeout=timeout)
             entries = [FileInfo(**item) for item in result]
             SYLogger.info(f"[Sandbox] 目录内容: {len(entries)} 项")
             return LsResult(entries=entries)
@@ -251,8 +251,10 @@ class FileOperationsMixin:
         file_path: str,
         offset: int = 0,
         limit: int = 2000,
+        *,
+        timeout: int = None,
     ) -> ReadResult:
-        """异步读取文件内容（真正的异步实现）"""
+        """异步读取文件内容"""
         try:
             await self._ensure_synced_async()
             SYLogger.info(
@@ -262,7 +264,7 @@ class FileOperationsMixin:
                 "user_id": self.user_id,
                 "offset": offset,
                 "limit": limit
-            })
+            }, timeout=timeout)
             if result.get("error"):
                 SYLogger.error(f"[Sandbox] 异步读取文件失败: {result['error']}")
                 return ReadResult(error=result["error"])
@@ -309,8 +311,10 @@ class FileOperationsMixin:
         self: "HTTPSandboxBackend",
         file_path: str,
         content: str,
+        *,
+        timeout: int = None,
     ) -> WriteResult:
-        """异步写入文件（真正的异步实现）"""
+        """异步写入文件"""
         try:
             await self._ensure_synced_async()
             SYLogger.info(f"[Sandbox] 异步写入文件: {file_path} ({len(content)} 字符)")
@@ -318,7 +322,7 @@ class FileOperationsMixin:
                 "file_path": file_path,
                 "content": base64.b64encode(content.encode()).decode(),
                 "user_id": self.user_id
-            })
+            }, timeout=timeout)
             write_result = WriteResult(
                 error=result.get("error"),
                 path=result.get("path")
@@ -364,8 +368,10 @@ class FileOperationsMixin:
         old_string: str,
         new_string: str,
         replace_all: bool = False,
+        *,
+        timeout: int = None,
     ) -> EditResult:
-        """异步编辑文件（真正的异步实现）"""
+        """异步编辑文件"""
         try:
             await self._ensure_synced_async()
             result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/edit", {
@@ -374,7 +380,7 @@ class FileOperationsMixin:
                 "new_string": base64.b64encode(new_string.encode()).decode(),
                 "user_id": self.user_id,
                 "replace_all": replace_all
-            })
+            }, timeout=timeout)
             return EditResult(
                 error=result.get("error"),
                 path=result.get("path"),
@@ -401,15 +407,15 @@ class FileOperationsMixin:
             SYLogger.error(f"[Sandbox] glob 搜索失败: {e}")
             return GlobResult(error=str(e))
 
-    async def aglob(self: "HTTPSandboxBackend", pattern: str, path: str = "/") -> GlobResult:
-        """异步 glob 搜索文件（真正的异步实现）"""
+    async def aglob(self: "HTTPSandboxBackend", pattern: str, path: str = "/", *, timeout: int = None) -> GlobResult:
+        """异步 glob 搜索文件"""
         try:
             await self._ensure_synced_async()
             result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/glob", {
                 "pattern": pattern,
                 "path": path,
                 "user_id": self.user_id
-            })
+            }, timeout=timeout)
             matches = [FileInfo(**item) for item in result]
             return GlobResult(matches=matches)
         except Exception as e:
@@ -438,7 +444,7 @@ class FileOperationsMixin:
             SYLogger.error(f"[Sandbox] tree 失败: {e}")
             return TreeResult(error=str(e))
 
-    async def atree(self: "HTTPSandboxBackend", path: str = "/", max_depth: int = 30, max_files: int = 0) -> TreeResult:
+    async def atree(self: "HTTPSandboxBackend", path: str = "/", max_depth: int = 30, max_files: int = 0, *, timeout: int = None) -> TreeResult:
         """异步以树形结构展示目录"""
         try:
             await self._ensure_synced_async()
@@ -448,7 +454,7 @@ class FileOperationsMixin:
                 "user_id": self.user_id,
                 "max_depth": max_depth,
                 "max_files": max_files,
-            })
+            }, timeout=timeout)
             if result.get("error"):
                 return TreeResult(error=result["error"])
             tree_node = TreeNode(
@@ -486,8 +492,10 @@ class FileOperationsMixin:
         pattern: str,
         path: str = None,
         glob: str = None,
+        *,
+        timeout: int = None,
     ) -> GrepResult:
-        """异步搜索文件内容（真正的异步实现）"""
+        """异步搜索文件内容"""
         try:
             await self._ensure_synced_async()
             result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/grep", {
@@ -495,7 +503,7 @@ class FileOperationsMixin:
                 "user_id": self.user_id,
                 "path": path,
                 "glob": glob
-            })
+            }, timeout=timeout)
             if isinstance(result, list):
                 matches = [GrepMatch(**item) for item in result]
                 return GrepResult(matches=matches)
@@ -545,16 +553,10 @@ class FileOperationsMixin:
         self: "HTTPSandboxBackend",
         path: str,
         recursive: bool = False,
+        *,
+        timeout: int = None,
     ) -> DeleteResult:
-        """异步删除文件或文件夹
-
-        Args:
-            path: 要删除的文件或文件夹路径
-            recursive: 是否递归删除（删除文件夹时需要设为 True）
-
-        Returns:
-            DeleteResult
-        """
+        """异步删除文件或文件夹"""
         try:
             await self._ensure_synced_async()
             SYLogger.info(f"[Sandbox] 异步删除: {path} (recursive={recursive})")
@@ -562,7 +564,7 @@ class FileOperationsMixin:
                 "path": path,
                 "user_id": self.user_id,
                 "recursive": recursive,
-            })
+            }, timeout=timeout)
             delete_result = DeleteResult(
                 path=result.get("path", path),
                 error=result.get("error"),
@@ -578,15 +580,15 @@ class FileOperationsMixin:
 
     # ============== 文件存在检查 ==============
 
-    async def astat(self: "HTTPSandboxBackend", path: str) -> "StatResult":
-        """异步检查文件或目录状态（使用 /stat 端点）"""
+    async def astat(self: "HTTPSandboxBackend", path: str, *, timeout: int = None) -> "StatResult":
+        """异步检查文件或目录状态"""
         try:
             await self._ensure_synced_async()
             SYLogger.info(f"[Sandbox] 异步查询文件状态: {path}")
             result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/stat", {
                 "path": path,
                 "user_id": self.user_id
-            })
+            }, timeout=timeout)
             return StatResult(
                 path=result.get("path", path),
                 exists=result.get("exists", False),

{sycommon_python_lib-0.2.2a12 → sycommon_python_lib-0.2.2a13}/src/sycommon/agent/sandbox/http_sandbox_backend.py

@@ -121,9 +121,6 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             "/", "-"
         )
 
-        # 共享 aiohttp session（延迟创建，在 __del__ / aclose 中关闭）
-        self._aiohttp_session: Optional[aiohttp.ClientSession] = None
-
     @classmethod
     def from_nacos(
         cls,
@@ -344,33 +341,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
 
     # ============== 内部方法 - 异步版本 ==============
 
-    async def _get_aiohttp_session(self) -> aiohttp.ClientSession:
-        """获取或创建共享 aiohttp session"""
-        if self._aiohttp_session is None or self._aiohttp_session.closed:
-            connector = aiohttp.TCPConnector(ssl=_SSL_CONTEXT)
-            self._aiohttp_session = aiohttp.ClientSession(connector=connector)
-        return self._aiohttp_session
-
-    async def aclose(self):
-        """关闭共享 aiohttp session"""
-        if self._aiohttp_session and not self._aiohttp_session.closed:
-            await self._aiohttp_session.close()
-            self._aiohttp_session = None
-
-    def __del__(self):
-        # best-effort close; asyncio loop may already be gone
-        if self._aiohttp_session and not self._aiohttp_session.closed:
-            try:
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    loop.create_task(self._aiohttp_session.close())
-                else:
-                    loop.run_until_complete(self._aiohttp_session.close())
-            except Exception:
-                pass
-
     async def _post_async(self, endpoint: str, data: dict, timeout: int = None) -> dict:
-        """真正的异步 POST 请求（使用共享 aiohttp session）"""
+        """异步 POST 请求（每次创建独立 session，避免跨 Task 共享导致超时上下文错误）"""
         actual_timeout = timeout if timeout is not None else self._timeout
         if "/execute" in endpoint:
             http_timeout = actual_timeout + 60
@@ -385,10 +357,10 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         url = f"{self._base_url}{endpoint}"
         SYLogger.info(f"[Sandbox] Async POST 请求开始: {url}, timeout={http_timeout}s")
 
-        session = await self._get_aiohttp_session()
-
-        async def _do_request():
-            async with session.post(url, json=data, headers=headers) as resp:
+        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()
@@ -398,8 +370,6 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 SYLogger.info(f"[Sandbox] Async POST 成功: {url}")
                 return result
 
-        return await asyncio.wait_for(_do_request(), timeout=http_timeout)
-
     async def _post_async_with_failover(self, endpoint: str, data: dict, timeout: int = None) -> dict:
         """带故障转移的异步 POST 请求"""
         max_retries = 3
@@ -486,15 +456,17 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         # 从沙箱服务端 health 接口获取（aiohttp 异步）
         try:
             url = f"{self._base_url}{SANDBOX_API_PREFIX}/health"
-            session = await self._get_aiohttp_session()
-            async with session.get(url) 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
+            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
         except Exception as e:
             SYLogger.warning(f"[Sandbox] 异步获取沙箱 workspace 失败: {e}")
 
@@ -557,7 +529,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 truncated=False
             )
 
-    async def _sync_async(self) -> dict:
+    async def _sync_async(self, *, timeout: int = None) -> dict:
         """同步目录（异步版本）
 
         sync_dirs 条目支持两种格式:
@@ -587,14 +559,14 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
 
             if is_dir:
                 SYLogger.info(f"[Sandbox] 开始上传目录: {local_path}")
-                result = await self._upload_directory_async(str(local_dir), remote_path, mode=mode)
+                result = await self._upload_directory_async(str(local_dir), remote_path, mode=mode, timeout=timeout)
                 results[local_path] = result
                 SYLogger.info(f"[Sandbox] 目录上传完成: {local_path}, 成功={result['success']}, 失败={result['failed']}")
             else:
                 # 单文件
                 SYLogger.info(f"[Sandbox] 上传单文件: {local_path}")
                 content = await asyncio.to_thread(lambda: open(local_dir, "rb").read())
-                upload_results = await self.aupload_files([(remote_path, content)])
+                upload_results = await self.aupload_files([(remote_path, content)], timeout=timeout)
                 if upload_results[0].error:
                     results[local_path] = {"success": 0, "failed": 1, "errors": [{"path": remote_path, "error": upload_results[0].error}]}
                 else:
@@ -604,7 +576,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         SYLogger.info("[Sandbox] _sync_async 完成")
         return results
 
-    async def _upload_directory_async(self, local_dir: str, remote_path: str = "/", *, mode: str = "full") -> dict:
+    async def _upload_directory_async(self, local_dir: str, remote_path: str = "/", *, mode: str = "full", timeout: int = None) -> dict:
         """上传整个目录到沙箱（异步版本）
 
         Args:
@@ -633,7 +605,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 ls_result = await self._post_async(f"{SANDBOX_API_PREFIX}/ls", {
                     "path": remote_path,
                     "user_id": self._user_id
-                })
+                }, timeout=timeout)
                 if ls_result and not ls_result.get("error"):
                     for item in ls_result.get("files", ls_result.get("children", [])):
                         if item.get("is_dir", False):
@@ -702,7 +674,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 return items
             batch_items = await asyncio.to_thread(_read_batch)
 
-            upload_results = await self.aupload_files(batch_items)
+            upload_results = await self.aupload_files(batch_items, timeout=timeout)
             for r in upload_results:
                 if r.error:
                     all_results.append({"ok": False, "path": r.path, "error": r.error})
@@ -742,71 +714,74 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         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"
-        session = await self._get_aiohttp_session()
-
-        async with session.post(url, json={
-            "command": command.strip(),
-            "user_id": self._user_id,
-            "timeout": actual_timeout
-        }) 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 = 600) -> dict:
+        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": timeout
-            })
+                "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) -> dict:
-        """异步检查后台进程状态（真正的异步实现）"""
+    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) -> dict:
-        """异步终止后台进程（真正的异步实现）"""
+    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) -> dict:
+    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}
+                {"user_id": self._user_id},
+                timeout=timeout,
             )
             SYLogger.info(
                 f"[Sandbox] 批量终止进程: "
@@ -820,21 +795,21 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
 
     # ============== 端口转发 ==============
 
-    async def aport_forward(self, port: int, action: str = "list") -> dict:
+    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) -> dict:
+    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)
 
     # ============== 批量操作 ==============
 
@@ -980,9 +955,9 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         """
         return self._sync_sync()
 
-    async def async_sync(self) -> dict:
-        """异步手动同步所有配置的目录到沙箱（真正的异步实现）"""
-        return await self._sync_async()
+    async def async_sync(self, *, timeout: int = None) -> dict:
+        """异步手动同步所有配置的目录到沙箱"""
+        return await self._sync_async(timeout=timeout)
 
     def sync_dirs(self, dirs: List[tuple[str, str]]) -> dict:
         """同步指定的目录列表到沙箱
@@ -1027,7 +1002,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         SYLogger.info("[Sandbox] sync_dirs 完成")
         return results
 
-    async def async_sync_dirs(self, dirs: List[tuple[str, str]]) -> dict:
+    async def async_sync_dirs(self, dirs: List[tuple[str, str]], *, timeout: int = None) -> dict:
         """异步同步指定的目录列表到沙箱（真正的异步实现）
 
         Args:
@@ -1057,13 +1032,13 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
 
             if is_dir:
                 SYLogger.info(f"[Sandbox] 开始异步上传目录: {local_path}")
-                result = await self._upload_directory_async(str(local_dir), remote_path)
+                result = await self._upload_directory_async(str(local_dir), remote_path, timeout=timeout)
                 results[local_path] = result
                 SYLogger.info(f"[Sandbox] 异步目录上传完成: {local_path}, 成功={result['success']}, 失败={result['failed']}")
             else:
                 SYLogger.info(f"[Sandbox] 异步上传单文件: {local_path}")
                 content = await asyncio.to_thread(lambda: open(local_dir, "rb").read())
-                upload_results = await self.aupload_files([(remote_path, content)])
+                upload_results = await self.aupload_files([(remote_path, content)], timeout=timeout)
                 if upload_results[0].error:
                     results[local_path] = {"success": 0, "failed": 1, "errors": [{"path": remote_path, "error": upload_results[0].error}]}
                 else:
@@ -1270,9 +1245,9 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         """重置沙箱环境"""
         return self._post_sync(f"{SANDBOX_API_PREFIX}/reset", {"user_id": self._user_id})
 
-    async def areset(self) -> dict:
+    async def areset(self, *, timeout: int = None) -> dict:
         """异步重置沙箱环境"""
-        return await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/reset", {"user_id": self._user_id})
+        return await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/reset", {"user_id": self._user_id}, timeout=timeout)
 
     def health_check(self, timeout: int = 10) -> dict:
         """健康检查（快速检查，默认10秒超时）"""
@@ -1297,16 +1272,18 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             SYLogger.error(f"[Sandbox] 健康检查失败: {e}")
             raise
 
-    async def ahealth_check(self) -> dict:
+    async def ahealth_check(self, timeout: int = 10) -> dict:
         """异步健康检查"""
         try:
             url = f"{self._base_url}{SANDBOX_API_PREFIX}/health"
-            session = await self._get_aiohttp_session()
-            async with session.get(url) as resp:
-                resp.raise_for_status()
-                result = await resp.json()
-                SYLogger.info(f"[Sandbox] 异步健康检查成功: {result}")
-                return result
+            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, 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

{sycommon_python_lib-0.2.2a12 → sycommon_python_lib-0.2.2a13}/src/sycommon_python_lib.egg-info/PKG-INFO

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