agentscope-runtime 0.1.5b2__py3-none-any.whl → 0.1.6__py3-none-any.whl

agentscope_runtime/sandbox/box/browser/browser_sandbox.py

@@ -3,10 +3,11 @@
 from typing import Optional
 from urllib.parse import urlparse, urlunparse
 
-from ...constant import IMAGE_TAG
+from ...utils import build_image_uri
 from ...registry import SandboxRegistry
 from ...enums import SandboxType
-from ...box.sandbox import Sandbox
+from ...box.base import BaseSandbox
+from ...box.gui import GUIMixin
 
 
 def http_to_ws(url, use_localhost=True):
@@ -27,35 +28,29 @@ def http_to_ws(url, use_localhost=True):
 
 
 @SandboxRegistry.register(
-    f"agentscope/runtime-sandbox-browser:{IMAGE_TAG}",
+    build_image_uri("runtime-sandbox-browser"),
     sandbox_type=SandboxType.BROWSER,
     security_level="medium",
     timeout=60,
     description="Browser sandbox",
 )
-class BrowserSandbox(Sandbox):
-    def __init__(
+class BrowserSandbox(GUIMixin, BaseSandbox):
+    def __init__(  # pylint: disable=useless-parent-delegation
         self,
         sandbox_id: Optional[str] = None,
         timeout: int = 3000,
         base_url: Optional[str] = None,
         bearer_token: Optional[str] = None,
+        sandbox_type: SandboxType = SandboxType.BROWSER,
     ):
         super().__init__(
             sandbox_id,
             timeout,
             base_url,
             bearer_token,
-            SandboxType.BROWSER,
+            sandbox_type,
         )
 
-    @property
-    def browser_ws(self):
-        if self.base_url is None:
-            # Local mode
-            return self.get_info()["front_browser_ws"]
-        return http_to_ws(f"{self.base_url}/browser/{self.sandbox_id}/cast")
-
     def browser_close(self):
         return self.call_tool("browser_close", {})
 

agentscope_runtime/sandbox/box/dummy/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+from .dummy_sandbox import DummySandbox
+
+__all__ = ["DummySandbox"]

agentscope_runtime/sandbox/box/filesystem/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+from .filesystem_sandbox import FilesystemSandbox
+
+__all__ = ["FilesystemSandbox"]

agentscope_runtime/sandbox/box/filesystem/filesystem_sandbox.py

@@ -2,33 +2,35 @@
 # pylint: disable=dangerous-default-value
 from typing import Optional
 
-from ...constant import IMAGE_TAG
+from ...utils import build_image_uri
 from ...registry import SandboxRegistry
 from ...enums import SandboxType
-from ...box.sandbox import Sandbox
+from ...box.base import BaseSandbox
+from ...box.gui import GUIMixin
 
 
 @SandboxRegistry.register(
-    f"agentscope/runtime-sandbox-filesystem:{IMAGE_TAG}",
+    build_image_uri("runtime-sandbox-filesystem"),
     sandbox_type=SandboxType.FILESYSTEM,
     security_level="medium",
     timeout=60,
     description="Filesystem sandbox",
 )
-class FilesystemSandbox(Sandbox):
-    def __init__(
+class FilesystemSandbox(GUIMixin, BaseSandbox):
+    def __init__(  # pylint: disable=useless-parent-delegation
         self,
         sandbox_id: Optional[str] = None,
         timeout: int = 3000,
         base_url: Optional[str] = None,
         bearer_token: Optional[str] = None,
+        sandbox_type: SandboxType = SandboxType.FILESYSTEM,
     ):
         super().__init__(
             sandbox_id,
             timeout,
             base_url,
             bearer_token,
-            SandboxType.FILESYSTEM,
+            sandbox_type,
         )
 
     def read_file(self, path: str):

agentscope_runtime/sandbox/box/gui/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+from .gui_sandbox import GuiSandbox, GUIMixin
+
+__all__ = ["GuiSandbox", "GUIMixin"]

agentscope_runtime/sandbox/box/gui/gui_sandbox.py

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+import logging
+from typing import Optional, Union, Tuple, List
+
+from urllib.parse import urljoin, urlencode
+
+from ...utils import build_image_uri, get_platform
+from ...registry import SandboxRegistry
+from ...enums import SandboxType
+from ...box.base import BaseSandbox
+
+logger = logging.getLogger(__name__)
+
+
+class GUIMixin:
+    @property
+    def desktop_url(self):
+        if not self.manager_api.check_health(identity=self.sandbox_id):
+            raise RuntimeError(f"Sandbox {self.sandbox_id} is not healthy")
+
+        info = self.get_info()
+        path = "/vnc/vnc_lite.html"
+        remote_path = "/vnc/vnc_relay.html"
+        params = {"password": info["runtime_token"]}
+
+        if self.base_url is None:
+            return urljoin(info["url"], path) + "?" + urlencode(params)
+
+        return (
+            f"{self.base_url}/desktop/{self.sandbox_id}{remote_path}"
+            f"?{urlencode(params)}"
+        )
+
+
+@SandboxRegistry.register(
+    build_image_uri("runtime-sandbox-gui"),
+    sandbox_type=SandboxType.GUI,
+    security_level="high",
+    timeout=30,
+    description="GUI Sandbox",
+)
+class GuiSandbox(GUIMixin, BaseSandbox):
+    def __init__(  # pylint: disable=useless-parent-delegation
+        self,
+        sandbox_id: Optional[str] = None,
+        timeout: int = 3000,
+        base_url: Optional[str] = None,
+        bearer_token: Optional[str] = None,
+        sandbox_type: SandboxType = SandboxType.GUI,
+    ):
+        super().__init__(
+            sandbox_id,
+            timeout,
+            base_url,
+            bearer_token,
+            sandbox_type,
+        )
+        if get_platform() == "linux/arm64":
+            logger.warning(
+                "\nCompatibility Notice: This GUI Sandbox may have issues on "
+                "arm64 CPU architectures, due to the computer-use-mcp does "
+                "not provide linux/arm64 compatibility. It has been tested "
+                "to work on Apple M4 chips with Rosetta enabled. However, "
+                "on M1, M2, and M3 chips, chromium browser might crash due "
+                "to the missing SSE3 instruction set.",
+            )
+
+    def computer_use(
+        self,
+        action: str,
+        coordinate: Optional[Union[List[float], Tuple[float, float]]] = None,
+        text: Optional[str] = None,
+    ):
+        payload = {"action": action}
+        if coordinate is not None:
+            payload["coordinate"] = coordinate
+        if text is not None:
+            payload["text"] = text
+
+        return self.call_tool("computer", payload)

agentscope_runtime/sandbox/box/sandbox.py

@@ -49,7 +49,7 @@ class Sandbox:
             )
 
             sandbox_id = self.manager_api.create_from_pool(
-                sandbox_type=sandbox_type.value,
+                sandbox_type=SandboxType(sandbox_type).value,
             )
             if sandbox_id is None:
                 raise RuntimeError(
@@ -115,8 +115,11 @@ class Sandbox:
                 # Clean the specific sandbox
                 self.manager_api.release(self.sandbox_id)
         except Exception as e:
+            import traceback
+
             logger.error(
-                f"Cleanup {self.sandbox_id} error: {e}",
+                f"Cleanup {self.sandbox_id} error: {e}\n"
+                f"{traceback.format_exc()}",
             )
 
     def __enter__(self):

agentscope_runtime/sandbox/box/shared/routers/generic.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 import io
+import sys
 import logging
 import subprocess
 import traceback
@@ -44,7 +45,25 @@ async def run_ipython_cell(
         stderr_buf = io.StringIO()
 
         with redirect_stdout(stdout_buf), redirect_stderr(stderr_buf):
-            ipy.run_cell(code)
+            preprocessing_exc_tuple = None
+            try:
+                transformed_cell = ipy.transform_cell(code)
+            except Exception:
+                transformed_cell = code
+                preprocessing_exc_tuple = sys.exc_info()
+
+            if transformed_cell is None:
+                raise HTTPException(
+                    status_code=500,
+                    detail="IPython cell transformation failed: "
+                    "transformed_cell is None.",
+                )
+
+            await ipy.run_cell_async(
+                code,
+                transformed_cell=transformed_cell,
+                preprocessing_exc_tuple=preprocessing_exc_tuple,
+            )
 
         stdout_content = stdout_buf.getvalue()
         stderr_content = stderr_buf.getvalue()

agentscope_runtime/sandbox/box/training_box/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+from .training_box import APPWorldSandbox, BFCLSandbox
+
+__all__ = ["APPWorldSandbox", "BFCLSandbox"]

agentscope_runtime/sandbox/box/training_box/training_box.py

@@ -5,21 +5,13 @@ Module for the Training Sandbox implementation.
 This module provides a sandbox environment for training tasks
 with specific configuration and tool calling methods.
 """
-import platform
 from typing import Dict, Optional
 import os
 
+from ...utils import build_image_uri
 from ...registry import SandboxRegistry
 from ...enums import SandboxType
 from ...box.sandbox import Sandbox
-from ...constant import IMAGE_TAG
-
-
-def get_image_tag() -> str:
-    machine = platform.machine().lower()
-    if machine in ("arm64", "aarch64", "armv7l", "armv8"):
-        return f"{IMAGE_TAG}-arm64"
-    return IMAGE_TAG
 
 
 class TrainingSandbox(Sandbox):
@@ -214,7 +206,7 @@ class TrainingSandbox(Sandbox):
 
 
 @SandboxRegistry.register(
-    f"agentscope/runtime-sandbox-appworld:{get_image_tag()}",
+    build_image_uri("runtime-sandbox-appworld", arm64_compatible=False),
     sandbox_type=SandboxType.APPWORLD,
     runtime_config={"shm_size": "5.06gb"},
     security_level="medium",
@@ -235,6 +227,7 @@ class APPWorldSandbox(TrainingSandbox):
         timeout: int = 3000,
         base_url: Optional[str] = None,
         bearer_token: Optional[str] = None,
+        sandbox_type: SandboxType = SandboxType.APPWORLD,
     ):
         """
         Initialize the Training Sandbox.
@@ -250,7 +243,7 @@ class APPWorldSandbox(TrainingSandbox):
             timeout,
             base_url,
             bearer_token,
-            SandboxType.APPWORLD,
+            sandbox_type,
         )
 
 
@@ -258,7 +251,7 @@ DATASET_SUB_TYPE = os.environ.get("DATASET_SUB_TYPE", "multi_turn")
 
 
 @SandboxRegistry.register(
-    f"agentscope/runtime-sandbox-bfcl:{get_image_tag()}",
+    build_image_uri("runtime-sandbox-bfcl", arm64_compatible=False),
     sandbox_type=SandboxType.BFCL,
     runtime_config={"shm_size": "8.06gb"},
     security_level="medium",
@@ -289,6 +282,7 @@ class BFCLSandbox(TrainingSandbox):
         timeout: int = 3000,
         base_url: Optional[str] = None,
         bearer_token: Optional[str] = None,
+        sandbox_type: SandboxType = SandboxType.BFCL,
     ):
         """
         Initialize the Training Sandbox.
@@ -304,12 +298,12 @@ class BFCLSandbox(TrainingSandbox):
             timeout,
             base_url,
             bearer_token,
-            SandboxType.BFCL,
+            sandbox_type,
         )
 
 
 @SandboxRegistry.register(
-    f"agentscope/runtime-sandbox-webshop:{get_image_tag()}",
+    build_image_uri("runtime-sandbox-webshop", arm64_compatible=False),
     sandbox_type=SandboxType.WEBSHOP,
     runtime_config={"shm_size": "5.06gb"},
     security_level="medium",
@@ -330,6 +324,7 @@ class WebShopSandbox(TrainingSandbox):
         timeout: int = 3000,
         base_url: Optional[str] = None,
         bearer_token: Optional[str] = None,
+        sandbox_type: SandboxType = SandboxType.WEBSHOP,
     ):
         """
         Initialize the Training Sandbox.
@@ -345,5 +340,5 @@ class WebShopSandbox(TrainingSandbox):
             timeout,
             base_url,
             bearer_token,
-            SandboxType.BFCL,
+            sandbox_type,
         )

agentscope_runtime/sandbox/build.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# pylint: disable=too-many-statements
+# pylint: disable=too-many-statements,too-many-branches
 import argparse
 import logging
 import os
@@ -11,6 +11,15 @@ import requests
 
 from .enums import SandboxType
 from .registry import SandboxRegistry
+from .utils import dynamic_import, get_platform
+
+
+logger = logging.getLogger(__name__)
+
+DOCKER_PLATFORMS = [
+    "linux/amd64",
+    "linux/arm64",
+]
 
 
 def find_free_port(start_port, end_port):
@@ -18,7 +27,7 @@ def find_free_port(start_port, end_port):
         with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
             if sock.connect_ex(("localhost", port)) != 0:
                 return port
-    logging.error(
+    logger.error(
         f"No free ports available in the range {start_port}-{end_port}",
     )
     raise RuntimeError(
@@ -30,7 +39,7 @@ def check_health(url, secret_token, timeout=120, interval=5):
     headers = {"Authorization": f"Bearer {secret_token}"}
     spent_time = 0
     while spent_time < timeout:
-        logging.info(
+        logger.info(
             f"Attempting to connect to {url} (Elapsed time: {spent_time} "
             f"seconds)...",
         )
@@ -41,35 +50,52 @@ def check_health(url, secret_token, timeout=120, interval=5):
                 return True
         except requests.exceptions.RequestException:
             pass
-        logging.info(
+        logger.info(
             f"Health check failed for {url}. Retrying in {interval} "
             f"seconds...",
         )
         time.sleep(interval)
         spent_time += interval
-    logging.error(f"Health check failed for {url} after {timeout} seconds.")
+    logger.error(f"Health check failed for {url} after {timeout} seconds.")
     return False
 
 
-def build_image(build_type, dockerfile_path=None):
+def build_image(
+    build_type,
+    dockerfile_path=None,
+    platform_choice="linux/amd64",
+):
+    assert platform_choice in DOCKER_PLATFORMS, (
+        f"Invalid platform: {platform_choice}. Valid options:"
+        f" {DOCKER_PLATFORMS}"
+    )
+
+    platform_tag = ""
+    if platform_choice == "linux/arm64":
+        platform_tag = "-arm64"
+
+    buildx_enable = platform_choice != get_platform()
+
     if dockerfile_path is None:
         dockerfile_path = (
             f"src/agentscope_runtime/sandbox/box/{build_type}/Dockerfile"
         )
 
-    logging.info(f"Building {build_type} with `{dockerfile_path}`...")
+    logger.info(f"Building {build_type} with `{dockerfile_path}`...")
 
     # Initialize and update Git submodule
-    logging.info("Initializing and updating Git submodule...")
+    logger.info("Initializing and updating Git submodule...")
     subprocess.run(
         ["git", "submodule", "update", "--init", "--recursive"],
         check=True,
     )
 
     secret_token = "secret_token123"
-    image_name = SandboxRegistry.get_image_by_type(build_type)
 
-    logging.info(f"Building Docker image {image_name}...")
+    # Add platform tag
+    image_name = SandboxRegistry.get_image_by_type(build_type) + platform_tag
+
+    logger.info(f"Building Docker image {image_name}...")
 
     # Check if image exists
     result = subprocess.run(
@@ -87,7 +113,7 @@ def build_image(build_type, dockerfile_path=None):
             f"you want to overwrite it? (y/N): ",
         )
         if choice.lower() != "y":
-            logging.info("Exiting without overwriting the existing image.")
+            logger.info("Exiting without overwriting the existing image.")
             return
 
     if not os.path.exists(dockerfile_path):
@@ -97,70 +123,101 @@ def build_image(build_type, dockerfile_path=None):
         )
 
     # Build Docker image
-    subprocess.run(
-        [
-            "docker",
-            "build",
-            "-f",
-            dockerfile_path,
-            "-t",
-            f"{image_name}dev",
-            ".",
-        ],
-        check=False,
-    )
-    logging.info(f"Docker image {image_name}dev built successfully.")
+    if not buildx_enable:
+        subprocess.run(
+            [
+                "docker",
+                "build",
+                "-f",
+                dockerfile_path,
+                "-t",
+                f"{image_name}dev",
+                ".",
+            ],
+            check=False,
+        )
+    else:
+        subprocess.run(
+            [
+                "docker",
+                "buildx",
+                "build",
+                "--platform",
+                platform_choice,
+                "-f",
+                dockerfile_path,
+                "-t",
+                f"{image_name}dev",
+                "--load",
+                ".",
+            ],
+            check=False,
+        )
 
-    logging.info(f"Start to build image {image_name}.")
+    logger.info(f"Docker image {image_name}dev built successfully.")
+
+    logger.info(f"Start to build image {image_name}.")
 
     # Run the container with port mapping and environment variable
     free_port = find_free_port(8080, 8090)
-    result = subprocess.run(
-        [
-            "docker",
-            "run",
-            "-d",
-            "-p",
-            f"{free_port}:80",
-            "-e",
-            f"SECRET_TOKEN={secret_token}",
-            f"{image_name}dev",
-        ],
-        capture_output=True,
-        text=True,
-        check=False,
-    )
+
+    if not buildx_enable:
+        result = subprocess.run(
+            [
+                "docker",
+                "run",
+                "-d",
+                "-p",
+                f"{free_port}:80",
+                "-e",
+                f"SECRET_TOKEN={secret_token}",
+                f"{image_name}dev",
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    else:
+        result = subprocess.run(
+            [
+                "docker",
+                "run",
+                "--platform",
+                platform_choice,
+                "-d",
+                "-p",
+                f"{free_port}:80",
+                "-e",
+                f"SECRET_TOKEN={secret_token}",
+                f"{image_name}dev",
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+
     container_id = result.stdout.strip()
-    logging.info(f"Running container {container_id} on port {free_port}")
+    logger.info(f"Running container {container_id} on port {free_port}")
 
     # Check health endpoints
     fastapi_health_url = f"http://localhost:{free_port}/fastapi/healthz"
-    steelapi_health_url = (
-        f"http://localhost:{free_port}/steel-api/{secret_token}/v1/health"
-    )
 
     # Check health for FASTAPI
     fastapi_healthy = check_health(fastapi_health_url, secret_token)
 
-    # Check health for Browser
-    if build_type in [SandboxType.BROWSER.value]:
-        browser_healthy = check_health(steelapi_health_url, secret_token)
-    else:
-        browser_healthy = True
-
-    if browser_healthy and fastapi_healthy:
-        logging.info("Health checks passed.")
+    if fastapi_healthy:
+        logger.info("Health checks passed.")
         subprocess.run(
             ["docker", "commit", container_id, f"{image_name}"],
             check=True,
         )
-        logging.info(
+        logger.info(
             f"Docker image {image_name} committed successfully.",
         )
         subprocess.run(["docker", "stop", container_id], check=True)
         subprocess.run(["docker", "rm", container_id], check=True)
     else:
-        logging.error("Health checks failed.")
+        logger.error("Health checks failed.")
         subprocess.run(["docker", "stop", container_id], check=True)
 
     choice = input(
@@ -171,9 +228,9 @@ def build_image(build_type, dockerfile_path=None):
             ["docker", "rmi", "-f", f"{image_name}dev"],
             check=True,
         )
-        logging.info(f"Dev image {image_name}dev deleted.")
+        logger.info(f"Dev image {image_name}dev deleted.")
     else:
-        logging.info(f"Dev image {image_name}dev retained.")
+        logger.info(f"Dev image {image_name}dev retained.")
 
 
 def main():
@@ -182,8 +239,8 @@ def main():
     )
     parser.add_argument(
         "build_type",
+        nargs="?",
         default="base",
-        choices=[x.value for x in SandboxType] + ["all"],
         help="Specify the build type to execute.",
     )
 
@@ -193,20 +250,48 @@ def main():
         help="Specify the path for the Dockerfile.",
     )
 
+    parser.add_argument(
+        "--extension",
+        action="append",
+        help="Path to a Python file or module name to load as an extension",
+    )
+
+    parser.add_argument(
+        "--platform",
+        default=get_platform(),
+        choices=DOCKER_PLATFORMS,
+        help="Specify target platform for Docker image (default: current "
+        f"system platform: {get_platform()})",
+    )
+
     args = parser.parse_args()
 
+    if args.extension:
+        for ext in args.extension:
+            logger.info(f"Loading extension: {ext}")
+            mod = dynamic_import(ext)
+            logger.info(f"Extension loaded: {mod.__name__}")
+
     if args.build_type == "all":
         # Only build the built-in images
         for build_type in [x.value for x in SandboxType.get_builtin_members()]:
             build_image(build_type)
     else:
+        assert args.build_type in [
+            x.value for x in SandboxType
+        ], f"Invalid build type: {args.build_type}"
+
         if args.build_type not in [
             x.value for x in SandboxType.get_builtin_members()
         ]:
             assert (
                 args.dockerfile_path is not None
             ), "Dockerfile path is required for custom images"
-        build_image(args.build_type, args.dockerfile_path)
+        build_image(
+            args.build_type,
+            args.dockerfile_path,
+            platform_choice=args.platform,
+        )
 
 
 if __name__ == "__main__":