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

agentscope_runtime/sandbox/__init__.py

@@ -3,6 +3,7 @@ from .custom import *
 from .box.base.base_sandbox import BaseSandbox
 from .box.browser.browser_sandbox import BrowserSandbox
 from .box.filesystem.filesystem_sandbox import FilesystemSandbox
+from .box.gui.gui_sandbox import GuiSandbox
 from .box.training_box.training_box import TrainingSandbox
 
 
@@ -10,5 +11,6 @@ __all__ = [
     "BaseSandbox",
     "BrowserSandbox",
     "FilesystemSandbox",
+    "GuiSandbox",
     "TrainingSandbox",
 ]

agentscope_runtime/sandbox/box/base/__init__.py

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

agentscope_runtime/sandbox/box/base/base_sandbox.py

@@ -1,17 +1,18 @@
 # -*- coding: utf-8 -*-
 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 ...constant import TIMEOUT
 
 
 @SandboxRegistry.register(
-    f"agentscope/runtime-sandbox-base:{IMAGE_TAG}",
+    build_image_uri("runtime-sandbox-base"),
     sandbox_type=SandboxType.BASE,
     security_level="medium",
-    timeout=30,
+    timeout=TIMEOUT,
     description="Base Sandbox",
 )
 class BaseSandbox(Sandbox):
@@ -21,13 +22,14 @@ class BaseSandbox(Sandbox):
         timeout: int = 3000,
         base_url: Optional[str] = None,
         bearer_token: Optional[str] = None,
+        sandbox_type: SandboxType = SandboxType.BASE,
     ):
         super().__init__(
             sandbox_id,
             timeout,
             base_url,
             bearer_token,
-            SandboxType.BASE,
+            sandbox_type,
         )
 
     def run_ipython_cell(self, code: str):

agentscope_runtime/sandbox/box/browser/__init__.py

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

agentscope_runtime/sandbox/box/browser/browser_sandbox.py

@@ -3,10 +3,12 @@
 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
+from ...constant import TIMEOUT
 
 
 def http_to_ws(url, use_localhost=True):
@@ -27,35 +29,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,
+    timeout=TIMEOUT,
     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/dummy/dummy_sandbox.py

@@ -4,13 +4,14 @@ from typing import Optional
 from ...registry import SandboxRegistry
 from ...enums import SandboxType
 from ...box.sandbox import Sandbox
+from ...constant import TIMEOUT
 
 
 @SandboxRegistry.register(
     "",
     sandbox_type=SandboxType.DUMMY,
     security_level="low",
-    timeout=30,
+    timeout=TIMEOUT,
     description="Dummy Sandbox",
 )
 class DummySandbox(Sandbox):

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,36 @@
 # 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
+from ...constant import TIMEOUT
 
 
 @SandboxRegistry.register(
-    f"agentscope/runtime-sandbox-filesystem:{IMAGE_TAG}",
+    build_image_uri("runtime-sandbox-filesystem"),
     sandbox_type=SandboxType.FILESYSTEM,
     security_level="medium",
-    timeout=60,
+    timeout=TIMEOUT,
     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,81 @@
+# -*- 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
+from ...constant import TIMEOUT
+
+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=TIMEOUT,
+    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,46 +298,5 @@ class BFCLSandbox(TrainingSandbox):
             timeout,
             base_url,
             bearer_token,
-            SandboxType.BFCL,
-        )
-
-
-@SandboxRegistry.register(
-    f"agentscope/runtime-sandbox-webshop:{get_image_tag()}",
-    sandbox_type=SandboxType.WEBSHOP,
-    runtime_config={"shm_size": "5.06gb"},
-    security_level="medium",
-    timeout=30,
-    description="webshop Sandbox",
-)
-class WebShopSandbox(TrainingSandbox):
-    """
-    Training Sandbox class for managing and executing training-related tasks.
-
-    This class provides methods to create, manage, and interact with
-    training environment instances using specialized tool calls.
-    """
-
-    def __init__(
-        self,
-        sandbox_id: Optional[str] = None,
-        timeout: int = 3000,
-        base_url: Optional[str] = None,
-        bearer_token: Optional[str] = None,
-    ):
-        """
-        Initialize the Training Sandbox.
-
-        Args:
-            sandbox_id (Optional[str]): Unique identifier for the sandbox.
-            timeout (int): Maximum time allowed for sandbox operations.
-            base_url (Optional[str]): Base URL for sandbox API.
-            bearer_token (Optional[str]): Authentication token for API access.
-        """
-        super().__init__(
-            sandbox_id,
-            timeout,
-            base_url,
-            bearer_token,
-            SandboxType.BFCL,
+            sandbox_type,
         )