agentscope-runtime 1.0.4__py3-none-any.whl → 1.0.4a1__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,12 +18,55 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
-class SandboxHttpClient(SandboxHttpBase):
+class SandboxHttpClient:
     """
     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,
@@ -37,9 +80,27 @@ class SandboxHttpClient(SandboxHttpBase):
             model (ContainerModel): The pydantic model representing the
             runtime sandbox.
         """
-        super().__init__(model, timeout, domain)
+        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
         self.session = requests.Session()
-        self.session.headers.update(self.headers)
+        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)
 
     def __enter__(self):
         # Wait for the runtime api server to be healthy
@@ -54,21 +115,6 @@ class SandboxHttpClient(SandboxHttpBase):
             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
@@ -77,8 +123,9 @@ class SandboxHttpClient(SandboxHttpBase):
         Returns:
             bool: True if the service is reachable, False otherwise
         """
+        endpoint = f"{self.base_url}/healthz"
         try:
-            response_api = self._request("get", f"{self.base_url}/healthz")
+            response_api = self.session.get(endpoint)
             return response_api.status_code == 200
         except requests.RequestException:
             return False
@@ -100,36 +147,50 @@ class SandboxHttpClient(SandboxHttpBase):
         """
         Add MCP servers to runtime.
         """
-        return self.safe_request(
-            "post",
-            f"{self.base_url}/mcp/add_servers",
-            json={
-                "server_configs": server_configs,
-                "overwrite": overwrite,
-            },
-        )
+        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)}],
+            }
 
     def list_tools(self, tool_type=None, **kwargs) -> dict:
-        """
-        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
+        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
             if tool_type:
-                return {tool_type: data.get(tool_type, {})}
-        return data
+                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)}],
+            }
 
     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 = {}
 
@@ -139,14 +200,25 @@ class SandboxHttpClient(SandboxHttpBase):
             elif name == "run_shell_command":
                 return self.run_shell_command(**arguments)
 
-        return self.safe_request(
-            "post",
-            f"{self.base_url}/mcp/call_tool",
-            json={
-                "tool_name": name,
-                "arguments": 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)}],
+            }
 
     def run_ipython_cell(
         self,
@@ -155,11 +227,21 @@ class SandboxHttpClient(SandboxHttpBase):
         ),
     ) -> dict:
         """Run an IPython cell."""
-        return self.safe_request(
-            "post",
-            f"{self.base_url}/tools/run_ipython_cell",
-            json={"code": code},
-        )
+        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)}],
+            }
 
     def run_shell_command(
         self,
@@ -168,22 +250,46 @@ class SandboxHttpClient(SandboxHttpBase):
         ),
     ) -> dict:
         """Run a shell command."""
-        return self.safe_request(
-            "post",
-            f"{self.base_url}/tools/run_shell_command",
-            json={"command": 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
 
     # 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.
         """
-        return self.safe_request(
-            "post",
-            f"{self.base_url}/watcher/commit_changes",
-            json={"commit_message": 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)}],
+            }
 
     def generate_diff(
         self,
@@ -194,17 +300,40 @@ class SandboxHttpClient(SandboxHttpBase):
         Generate the diff between two commits or between uncommitted changes
         and the latest commit.
         """
-        return self.safe_request(
-            "post",
-            f"{self.base_url}/watcher/generate_diff",
-            json={"commit_a": commit_a, "commit_b": commit_b},
-        )
+        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)}],
+            }
 
     def git_logs(self) -> dict:
         """
         Retrieve the git logs.
         """
-        return self.safe_request("get", f"{self.base_url}/watcher/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)}],
+            }
 
     def get_workspace_file(self, file_path: str) -> dict:
         """
@@ -246,12 +375,27 @@ class SandboxHttpClient(SandboxHttpBase):
         """
         Create or edit a file within the /workspace directory.
         """
-        return self.safe_request(
-            "post",
-            f"{self.base_url}/workspace/files",
-            params={"file_path": file_path},
-            json={"content": content},
-        )
+        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)}],
+            }
 
     def list_workspace_directories(
         self,
@@ -260,31 +404,68 @@ class SandboxHttpClient(SandboxHttpBase):
         """
         List files in the specified directory within the /workspace.
         """
-        return self.safe_request(
-            "get",
-            f"{self.base_url}/workspace/list-directories",
-            params={"directory": directory},
-        )
+        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)}],
+            }
 
     def create_workspace_directory(self, directory_path: str) -> dict:
         """
         Create a directory within the /workspace directory.
         """
-        return self.safe_request(
-            "post",
-            f"{self.base_url}/workspace/directories",
-            params={"directory_path": directory_path},
-        )
+        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)}],
+            }
 
     def delete_workspace_file(self, file_path: str) -> dict:
         """
         Delete a file within the /workspace directory.
         """
-        return self.safe_request(
-            "delete",
-            f"{self.base_url}/workspace/files",
-            params={"file_path": file_path},
-        )
+        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)}],
+            }
 
     def delete_workspace_directory(
         self,
@@ -294,11 +475,24 @@ class SandboxHttpClient(SandboxHttpBase):
         """
         Delete a directory within the /workspace directory.
         """
-        return self.safe_request(
-            "delete",
-            f"{self.base_url}/workspace/directories",
-            params={"directory_path": directory_path, "recursive": recursive},
-        )
+        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)}],
+            }
 
     def move_or_rename_workspace_item(
         self,
@@ -308,14 +502,28 @@ class SandboxHttpClient(SandboxHttpBase):
         """
         Move or rename a file or directory within the /workspace directory.
         """
-        return self.safe_request(
-            "put",
-            f"{self.base_url}/workspace/move",
-            params={
+        try:
+            endpoint = 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,
@@ -325,11 +533,24 @@ class SandboxHttpClient(SandboxHttpBase):
         """
         Copy a file or directory within the /workspace directory.
         """
-        return self.safe_request(
-            "post",
-            f"{self.base_url}/workspace/copy",
-            params={
+        try:
+            endpoint = 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,10 +70,3 @@ 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"