agentscope-runtime 1.0.3__py3-none-any.whl → 1.0.4__py3-none-any.whl

agentscope_runtime/sandbox/client/http_client.py

@@ -3,11 +3,11 @@
 import logging
 import time
 from typing import Any, Optional
-from urllib.parse import urljoin
 
 import requests
 from pydantic import Field
 
+from .base import SandboxHttpBase
 from ..model import ContainerModel
 
 
@@ -18,55 +18,12 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
-class SandboxHttpClient:
+class SandboxHttpClient(SandboxHttpBase):
     """
     A Python client for interacting with the runtime API. Connect with
     container directly.
     """
 
-    _generic_tools = {
-        "run_ipython_cell": {
-            "name": "run_ipython_cell",
-            "json_schema": {
-                "type": "function",
-                "function": {
-                    "name": "run_ipython_cell",
-                    "description": "Run an IPython cell.",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {
-                            "code": {
-                                "type": "string",
-                                "description": "IPython code to execute",
-                            },
-                        },
-                        "required": ["code"],
-                    },
-                },
-            },
-        },
-        "run_shell_command": {
-            "name": "run_shell_command",
-            "json_schema": {
-                "type": "function",
-                "function": {
-                    "name": "run_shell_command",
-                    "description": "Run a shell command.",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {
-                            "command": {
-                                "type": "string",
-                                "description": "Shell command to execute",
-                            },
-                        },
-                        "required": ["command"],
-                    },
-                },
-            },
-        },
-    }
-
     def __init__(
         self,
         model: Optional[ContainerModel] = None,
@@ -80,27 +37,9 @@ class SandboxHttpClient:
             model (ContainerModel): The pydantic model representing the
             runtime sandbox.
         """
-        self.session_id = model.session_id
-        self.base_url = urljoin(
-            model.url.replace("localhost", domain),
-            "fastapi",
-        )
-
-        self.start_timeout = timeout
-        self.timeout = model.timeout or DEFAULT_TIMEOUT
+        super().__init__(model, timeout, domain)
         self.session = requests.Session()
-        self.built_in_tools = []
-        self.secret = model.runtime_token
-
-        # Update headers with secret if provided
-        headers = {
-            "Content-Type": "application/json",
-            "x-agentrun-session-id": "s" + self.session_id,
-            "x-agentscope-runtime-session-id": "s" + self.session_id,
-        }
-        if self.secret:
-            headers["Authorization"] = f"Bearer {self.secret}"
-        self.session.headers.update(headers)
+        self.session.headers.update(self.headers)
 
     def __enter__(self):
         # Wait for the runtime api server to be healthy
@@ -115,6 +54,21 @@ class SandboxHttpClient:
             kwargs["timeout"] = self.timeout
         return self.session.request(method, url, **kwargs)
 
+    def safe_request(self, method, url, **kwargs):
+        try:
+            r = self._request(method, url, **kwargs)
+            r.raise_for_status()
+            try:
+                return r.json()
+            except ValueError:
+                return r.text
+        except requests.exceptions.RequestException as e:
+            logger.error(f"HTTP error: {e}")
+            return {
+                "isError": True,
+                "content": [{"type": "text", "text": str(e)}],
+            }
+
     def check_health(self) -> bool:
         """
         Checks if the runtime service is running by verifying the health
@@ -123,9 +77,8 @@ class SandboxHttpClient:
         Returns:
             bool: True if the service is reachable, False otherwise
         """
-        endpoint = f"{self.base_url}/healthz"
         try:
-            response_api = self.session.get(endpoint)
+            response_api = self._request("get", f"{self.base_url}/healthz")
             return response_api.status_code == 200
         except requests.RequestException:
             return False
@@ -147,50 +100,36 @@ class SandboxHttpClient:
         """
         Add MCP servers to runtime.
         """
-        try:
-            endpoint = f"{self.base_url}/mcp/add_servers"
-            response = self._request(
-                "post",
-                endpoint,
-                json={
-                    "server_configs": server_configs,
-                    "overwrite": overwrite,
-                },
-            )
-            response.raise_for_status()
-            return response.text
-        except requests.exceptions.RequestException as e:
-            logger.error(f"An error occurred while adding MCP servers: {e}")
-            return {
-                "isError": True,
-                "content": [{"type": "text", "text": str(e)}],
-            }
+        return self.safe_request(
+            "post",
+            f"{self.base_url}/mcp/add_servers",
+            json={
+                "server_configs": server_configs,
+                "overwrite": overwrite,
+            },
+        )
 
     def list_tools(self, tool_type=None, **kwargs) -> dict:
-        try:
-            endpoint = f"{self.base_url}/mcp/list_tools"
-            response = self._request(
-                "get",
-                endpoint,
-            )
-            response.raise_for_status()
-            mcp_tools = response.json()
-            mcp_tools["generic"] = self.generic_tools
+        """
+        List available MCP tools plus generic built-in tools.
+        """
+        data = self.safe_request("get", f"{self.base_url}/mcp/list_tools")
+        if isinstance(data, dict) and "isError" not in data:
+            data["generic"] = self.generic_tools
             if tool_type:
-                return {tool_type: mcp_tools.get(tool_type, {})}
-            return mcp_tools
-        except requests.exceptions.RequestException as e:
-            logging.error(f"An error occurred: {e}")
-            return {
-                "isError": True,
-                "content": [{"type": "text", "text": str(e)}],
-            }
+                return {tool_type: data.get(tool_type, {})}
+        return data
 
     def call_tool(
         self,
         name: str,
         arguments: Optional[dict[str, Any]] = None,
     ) -> dict:
+        """
+        Call a specific MCP tool.
+
+        If it's a generic tool, call the corresponding local method.
+        """
         if arguments is None:
             arguments = {}
 
@@ -200,25 +139,14 @@ class SandboxHttpClient:
             elif name == "run_shell_command":
                 return self.run_shell_command(**arguments)
 
-        try:
-            endpoint = f"{self.base_url}/mcp/call_tool"
-            response = self._request(
-                "post",
-                endpoint,
-                json={
-                    "tool_name": name,
-                    "arguments": arguments,
-                },
-            )
-            response.raise_for_status()
-
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            logger.error(f"An error occurred: {e}")
-            return {
-                "isError": True,
-                "content": [{"type": "text", "text": str(e)}],
-            }
+        return self.safe_request(
+            "post",
+            f"{self.base_url}/mcp/call_tool",
+            json={
+                "tool_name": name,
+                "arguments": arguments,
+            },
+        )
 
     def run_ipython_cell(
         self,
@@ -227,21 +155,11 @@ class SandboxHttpClient:
         ),
     ) -> dict:
         """Run an IPython cell."""
-        try:
-            endpoint = f"{self.base_url}/tools/run_ipython_cell"
-            response = self._request(
-                "post",
-                endpoint,
-                json={"code": code},
-            )
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            logger.error(f"An error occurred: {e}")
-            return {
-                "isError": True,
-                "content": [{"type": "text", "text": str(e)}],
-            }
+        return self.safe_request(
+            "post",
+            f"{self.base_url}/tools/run_ipython_cell",
+            json={"code": code},
+        )
 
     def run_shell_command(
         self,
@@ -250,46 +168,22 @@ class SandboxHttpClient:
         ),
     ) -> dict:
         """Run a shell command."""
-        try:
-            endpoint = f"{self.base_url}/tools/run_shell_command"
-            response = self._request(
-                "post",
-                endpoint,
-                json={"command": command},
-            )
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            logger.error(f"An error occurred: {e}")
-            return {
-                "isError": True,
-                "content": [{"type": "text", "text": str(e)}],
-            }
-
-    @property
-    def generic_tools(self) -> dict:
-        return self._generic_tools
+        return self.safe_request(
+            "post",
+            f"{self.base_url}/tools/run_shell_command",
+            json={"command": command},
+        )
 
     # Below the method is used by API Server
     def commit_changes(self, commit_message: str = "Automated commit") -> dict:
         """
         Commit the uncommitted changes with a given commit message.
         """
-        try:
-            endpoint = f"{self.base_url}/watcher/commit_changes"
-            response = self._request(
-                "post",
-                endpoint,
-                json={"commit_message": commit_message},
-            )
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            logger.error(f"An error occurred while committing changes: {e}")
-            return {
-                "isError": True,
-                "content": [{"type": "text", "text": str(e)}],
-            }
+        return self.safe_request(
+            "post",
+            f"{self.base_url}/watcher/commit_changes",
+            json={"commit_message": commit_message},
+        )
 
     def generate_diff(
         self,
@@ -300,40 +194,17 @@ class SandboxHttpClient:
         Generate the diff between two commits or between uncommitted changes
         and the latest commit.
         """
-        try:
-            endpoint = f"{self.base_url}/watcher/generate_diff"
-            response = self._request(
-                "post",
-                endpoint,
-                json={"commit_a": commit_a, "commit_b": commit_b},
-            )
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            logger.error(f"An error occurred while generating diff: {e}")
-            return {
-                "isError": True,
-                "content": [{"type": "text", "text": str(e)}],
-            }
+        return self.safe_request(
+            "post",
+            f"{self.base_url}/watcher/generate_diff",
+            json={"commit_a": commit_a, "commit_b": commit_b},
+        )
 
     def git_logs(self) -> dict:
         """
         Retrieve the git logs.
         """
-        try:
-            endpoint = f"{self.base_url}/watcher/git_logs"
-            response = self._request(
-                "get",
-                endpoint,
-            )
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            logger.error(f"An error occurred while retrieving git logs: {e}")
-            return {
-                "isError": True,
-                "content": [{"type": "text", "text": str(e)}],
-            }
+        return self.safe_request("get", f"{self.base_url}/watcher/git_logs")
 
     def get_workspace_file(self, file_path: str) -> dict:
         """
@@ -375,27 +246,12 @@ class SandboxHttpClient:
         """
         Create or edit a file within the /workspace directory.
         """
-        try:
-            endpoint = f"{self.base_url}/workspace/files"
-            params = {"file_path": file_path}
-            data = {"content": content}
-            response = self._request(
-                "post",
-                endpoint,
-                params=params,
-                json=data,
-            )
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            logger.error(
-                f"An error occurred while creating or editing a workspace "
-                f"file: {e}",
-            )
-            return {
-                "isError": True,
-                "content": [{"type": "text", "text": str(e)}],
-            }
+        return self.safe_request(
+            "post",
+            f"{self.base_url}/workspace/files",
+            params={"file_path": file_path},
+            json={"content": content},
+        )
 
     def list_workspace_directories(
         self,
@@ -404,68 +260,31 @@ class SandboxHttpClient:
         """
         List files in the specified directory within the /workspace.
         """
-        try:
-            endpoint = f"{self.base_url}/workspace/list-directories"
-            params = {"directory": directory}
-            response = self._request(
-                "get",
-                endpoint,
-                params=params,
-            )
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            logger.error(f"An error occurred while listing files: {e}")
-            return {
-                "isError": True,
-                "content": [{"type": "text", "text": str(e)}],
-            }
+        return self.safe_request(
+            "get",
+            f"{self.base_url}/workspace/list-directories",
+            params={"directory": directory},
+        )
 
     def create_workspace_directory(self, directory_path: str) -> dict:
         """
         Create a directory within the /workspace directory.
         """
-        try:
-            endpoint = f"{self.base_url}/workspace/directories"
-            params = {"directory_path": directory_path}
-            response = self._request(
-                "post",
-                endpoint,
-                params=params,
-            )
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            logger.error(
-                f"An error occurred while creating a workspace directory: {e}",
-            )
-            return {
-                "isError": True,
-                "content": [{"type": "text", "text": str(e)}],
-            }
+        return self.safe_request(
+            "post",
+            f"{self.base_url}/workspace/directories",
+            params={"directory_path": directory_path},
+        )
 
     def delete_workspace_file(self, file_path: str) -> dict:
         """
         Delete a file within the /workspace directory.
         """
-        try:
-            endpoint = f"{self.base_url}/workspace/files"
-            params = {"file_path": file_path}
-            response = self._request(
-                "delete",
-                endpoint,
-                params=params,
-            )
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            logger.error(
-                f"An error occurred while deleting a workspace file: {e}",
-            )
-            return {
-                "isError": True,
-                "content": [{"type": "text", "text": str(e)}],
-            }
+        return self.safe_request(
+            "delete",
+            f"{self.base_url}/workspace/files",
+            params={"file_path": file_path},
+        )
 
     def delete_workspace_directory(
         self,
@@ -475,24 +294,11 @@ class SandboxHttpClient:
         """
         Delete a directory within the /workspace directory.
         """
-        try:
-            endpoint = f"{self.base_url}/workspace/directories"
-            params = {"directory_path": directory_path, "recursive": recursive}
-            response = self._request(
-                "delete",
-                endpoint,
-                params=params,
-            )
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            logger.error(
-                f"An error occurred while deleting a workspace directory: {e}",
-            )
-            return {
-                "isError": True,
-                "content": [{"type": "text", "text": str(e)}],
-            }
+        return self.safe_request(
+            "delete",
+            f"{self.base_url}/workspace/directories",
+            params={"directory_path": directory_path, "recursive": recursive},
+        )
 
     def move_or_rename_workspace_item(
         self,
@@ -502,28 +308,14 @@ class SandboxHttpClient:
         """
         Move or rename a file or directory within the /workspace directory.
         """
-        try:
-            endpoint = f"{self.base_url}/workspace/move"
-            params = {
+        return self.safe_request(
+            "put",
+            f"{self.base_url}/workspace/move",
+            params={
                 "source_path": source_path,
                 "destination_path": destination_path,
-            }
-            response = self._request(
-                "put",
-                endpoint,
-                params=params,
-            )
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            logger.error(
-                f"An error occurred while moving or renaming a workspace "
-                f"item: {e}",
-            )
-            return {
-                "isError": True,
-                "content": [{"type": "text", "text": str(e)}],
-            }
+            },
+        )
 
     def copy_workspace_item(
         self,
@@ -533,24 +325,11 @@ class SandboxHttpClient:
         """
         Copy a file or directory within the /workspace directory.
         """
-        try:
-            endpoint = f"{self.base_url}/workspace/copy"
-            params = {
+        return self.safe_request(
+            "post",
+            f"{self.base_url}/workspace/copy",
+            params={
                 "source_path": source_path,
                 "destination_path": destination_path,
-            }
-            response = self._request(
-                "post",
-                endpoint,
-                params=params,
-            )
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            logger.error(
-                f"An error occurred while copying a workspace item: {e}",
-            )
-            return {
-                "isError": True,
-                "content": [{"type": "text", "text": str(e)}],
-            }
+            },
+        )

agentscope_runtime/sandbox/enums.py

@@ -70,3 +70,10 @@ class SandboxType(DynamicEnum):
     APPWORLD = "appworld"
     BFCL = "bfcl"
     AGENTBAY = "agentbay"
+
+    # Async sandbox
+    BASE_ASYNC = "base_async"
+    BROWSER_ASYNC = "browser_async"
+    FILESYSTEM_ASYNC = "filesystem_async"
+    GUI_ASYNC = "gui_async"
+    MOBILE_ASYNC = "mobile_async"