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

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__":

agentscope_runtime/sandbox/client/http_client.py

@@ -3,15 +3,16 @@
 import logging
 import time
 from typing import Any, Optional
+from urllib.parse import urljoin
 
 import requests
 from pydantic import Field
-from steel import Steel
 
 from ..model import ContainerModel
-from ..constant import BROWSER_SESSION_ID
 
 
+DEFAULT_TIMEOUT = 60
+
 logging.getLogger("httpx").setLevel(logging.CRITICAL)
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -69,8 +70,7 @@ class SandboxHttpClient:
     def __init__(
         self,
         model: Optional[ContainerModel] = None,
-        timeout: int = 30,
-        enable_browser: bool = True,
+        timeout: int = 60,
         domain: str = "localhost",
     ) -> None:
         """
@@ -81,54 +81,39 @@ class SandboxHttpClient:
             runtime sandbox.
         """
         self.session_id = model.session_id
-        self.base_url = model.base_url.replace("localhost", domain)
-        self.browser_url = model.browser_url.replace("localhost", domain)
-        self.client_browser_ws = model.client_browser_ws.replace(
-            "localhost",
-            domain,
+        self.base_url = urljoin(
+            model.url.replace("localhost", domain),
+            "fastapi",
         )
 
-        self.enable_browser = enable_browser
-        self.timeout = timeout
+        self.start_timeout = timeout
+        self.timeout = model.timeout or DEFAULT_TIMEOUT
         self.session = requests.Session()
         self.built_in_tools = []
         self.secret = model.runtime_token
 
         # Update headers with secret if provided
-        headers = {"Content-Type": "application/json"}
+        headers = {
+            "Content-Type": "application/json",
+            "x-agentrun-session-id": "s" + self.session_id,
+        }
         if self.secret:
             headers["Authorization"] = f"Bearer {self.secret}"
         self.session.headers.update(headers)
 
-        self.steel_client = None
-
     def __enter__(self):
         # Wait for the runtime api server to be healthy
         self.wait_until_healthy()
-
-        if self.enable_browser:
-            self.steel_client = Steel(
-                steel_api_key="dummy",
-                base_url=self.browser_url,
-            )
-
-            # Create a new browser session if it doesn't exist
-            try:
-                # Try to connet to existing session
-                self.steel_client.sessions.retrieve(
-                    BROWSER_SESSION_ID,
-                )
-            except Exception:
-                # Session not found, create a new one
-                self.steel_client.sessions.create(
-                    session_id=BROWSER_SESSION_ID,
-                )
-
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):
         pass
 
+    def _request(self, method: str, url: str, **kwargs):
+        if "timeout" not in kwargs:
+            kwargs["timeout"] = self.timeout
+        return self.session.request(method, url, **kwargs)
+
     def check_health(self) -> bool:
         """
         Checks if the runtime service is running by verifying the health
@@ -138,17 +123,9 @@ class SandboxHttpClient:
             bool: True if the service is reachable, False otherwise
         """
         endpoint = f"{self.base_url}/healthz"
-        browser_endpoint = f"{self.browser_url}/v1/health"
         try:
             response_api = self.session.get(endpoint)
-            if self.enable_browser:
-                response_browser = self.session.get(browser_endpoint)
-                return (
-                    response_api.status_code == 200
-                    and response_browser.status_code == 200
-                )
-            else:
-                return response_api.status_code == 200
+            return response_api.status_code == 200
         except requests.RequestException:
             return False
 
@@ -157,7 +134,7 @@ class SandboxHttpClient:
         Waits until the runtime service is running for a specified timeout.
         """
         start_time = time.time()
-        while time.time() - start_time < self.timeout:
+        while time.time() - start_time < self.start_timeout:
             if self.check_health():
                 return
             time.sleep(1)
@@ -171,7 +148,8 @@ class SandboxHttpClient:
         """
         try:
             endpoint = f"{self.base_url}/mcp/add_servers"
-            response = self.session.post(
+            response = self._request(
+                "post",
                 endpoint,
                 json={
                     "server_configs": server_configs,
@@ -190,7 +168,10 @@ class SandboxHttpClient:
     def list_tools(self, tool_type=None, **kwargs) -> dict:
         try:
             endpoint = f"{self.base_url}/mcp/list_tools"
-            response = self.session.get(endpoint)
+            response = self._request(
+                "get",
+                endpoint,
+            )
             response.raise_for_status()
             mcp_tools = response.json()
             mcp_tools["generic"] = self.generic_tools
@@ -220,7 +201,8 @@ class SandboxHttpClient:
 
         try:
             endpoint = f"{self.base_url}/mcp/call_tool"
-            response = self.session.post(
+            response = self._request(
+                "post",
                 endpoint,
                 json={
                     "tool_name": name,
@@ -246,7 +228,11 @@ class SandboxHttpClient:
         """Run an IPython cell."""
         try:
             endpoint = f"{self.base_url}/tools/run_ipython_cell"
-            response = self.session.post(endpoint, json={"code": code})
+            response = self._request(
+                "post",
+                endpoint,
+                json={"code": code},
+            )
             response.raise_for_status()
             return response.json()
         except requests.exceptions.RequestException as e:
@@ -265,7 +251,11 @@ class SandboxHttpClient:
         """Run a shell command."""
         try:
             endpoint = f"{self.base_url}/tools/run_shell_command"
-            response = self.session.post(endpoint, json={"command": command})
+            response = self._request(
+                "post",
+                endpoint,
+                json={"command": command},
+            )
             response.raise_for_status()
             return response.json()
         except requests.exceptions.RequestException as e:
@@ -286,7 +276,8 @@ class SandboxHttpClient:
         """
         try:
             endpoint = f"{self.base_url}/watcher/commit_changes"
-            response = self.session.post(
+            response = self._request(
+                "post",
                 endpoint,
                 json={"commit_message": commit_message},
             )
@@ -310,7 +301,8 @@ class SandboxHttpClient:
         """
         try:
             endpoint = f"{self.base_url}/watcher/generate_diff"
-            response = self.session.post(
+            response = self._request(
+                "post",
                 endpoint,
                 json={"commit_a": commit_a, "commit_b": commit_b},
             )
@@ -329,7 +321,10 @@ class SandboxHttpClient:
         """
         try:
             endpoint = f"{self.base_url}/watcher/git_logs"
-            response = self.session.get(endpoint)
+            response = self._request(
+                "get",
+                endpoint,
+            )
             response.raise_for_status()
             return response.json()
         except requests.exceptions.RequestException as e:
@@ -346,7 +341,11 @@ class SandboxHttpClient:
         try:
             endpoint = f"{self.base_url}/workspace/files"
             params = {"file_path": file_path}
-            response = self.session.get(endpoint, params=params)
+            response = self._request(
+                "get",
+                endpoint,
+                params=params,
+            )
             response.raise_for_status()
             # Return the binary content of the file
             # Check for empty content
@@ -379,7 +378,12 @@ class SandboxHttpClient:
             endpoint = f"{self.base_url}/workspace/files"
             params = {"file_path": file_path}
             data = {"content": content}
-            response = self.session.post(endpoint, params=params, json=data)
+            response = self._request(
+                "post",
+                endpoint,
+                params=params,
+                json=data,
+            )
             response.raise_for_status()
             return response.json()
         except requests.exceptions.RequestException as e:
@@ -402,7 +406,11 @@ class SandboxHttpClient:
         try:
             endpoint = f"{self.base_url}/workspace/list-directories"
             params = {"directory": directory}
-            response = self.session.get(endpoint, params=params)
+            response = self._request(
+                "get",
+                endpoint,
+                params=params,
+            )
             response.raise_for_status()
             return response.json()
         except requests.exceptions.RequestException as e:
@@ -419,7 +427,11 @@ class SandboxHttpClient:
         try:
             endpoint = f"{self.base_url}/workspace/directories"
             params = {"directory_path": directory_path}
-            response = self.session.post(endpoint, params=params)
+            response = self._request(
+                "post",
+                endpoint,
+                params=params,
+            )
             response.raise_for_status()
             return response.json()
         except requests.exceptions.RequestException as e:
@@ -438,7 +450,11 @@ class SandboxHttpClient:
         try:
             endpoint = f"{self.base_url}/workspace/files"
             params = {"file_path": file_path}
-            response = self.session.delete(endpoint, params=params)
+            response = self._request(
+                "delete",
+                endpoint,
+                params=params,
+            )
             response.raise_for_status()
             return response.json()
         except requests.exceptions.RequestException as e:
@@ -461,7 +477,11 @@ class SandboxHttpClient:
         try:
             endpoint = f"{self.base_url}/workspace/directories"
             params = {"directory_path": directory_path, "recursive": recursive}
-            response = self.session.delete(endpoint, params=params)
+            response = self._request(
+                "delete",
+                endpoint,
+                params=params,
+            )
             response.raise_for_status()
             return response.json()
         except requests.exceptions.RequestException as e:
@@ -487,7 +507,11 @@ class SandboxHttpClient:
                 "source_path": source_path,
                 "destination_path": destination_path,
             }
-            response = self.session.put(endpoint, params=params)
+            response = self._request(
+                "put",
+                endpoint,
+                params=params,
+            )
             response.raise_for_status()
             return response.json()
         except requests.exceptions.RequestException as e:
@@ -514,7 +538,11 @@ class SandboxHttpClient:
                 "source_path": source_path,
                 "destination_path": destination_path,
             }
-            response = self.session.post(endpoint, params=params)
+            response = self._request(
+                "post",
+                endpoint,
+                params=params,
+            )
             response.raise_for_status()
             return response.json()
         except requests.exceptions.RequestException as e:

agentscope_runtime/sandbox/client/training_client.py

@@ -212,7 +212,6 @@ class TrainingSandboxClient:
     def list_tools(self, **kwargs):
         """list tools"""
         if "instance_id" in kwargs:
-            # 只传get_tools_info的方法参数
             return self.get_tools_info(
                 instance_id=kwargs.get("instance_id"),
                 messages=kwargs.get("messages", {}),

agentscope_runtime/sandbox/constant.py

@@ -1,5 +1,31 @@
 # -*- coding: utf-8 -*-
 import os
+import sys
+import logging
 
+logger = logging.getLogger(__name__)
+
+# Image Registry: default "", means using Docker Hub.
+# For AgentScope official registry, use
+# "agentscope-registry.ap-southeast-1.cr.aliyuncs.com"
+REGISTRY = os.getenv("RUNTIME_SANDBOX_REGISTRY", "")
+if REGISTRY == "":
+    agentscope_acr = "agentscope-registry.ap-southeast-1.cr.aliyuncs.com"
+    if sys.platform.startswith("win"):
+        cmd = f"set RUNTIME_SANDBOX_REGISTRY={agentscope_acr}"
+    else:
+        cmd = f"export RUNTIME_SANDBOX_REGISTRY={agentscope_acr}"
+    logger.warning(
+        "Using Docker Hub as image registry. If pulling is slow or fails, "
+        f"you can switch to the AgentScope official registry by running:\n  "
+        f"{cmd}\n",
+    )
+
+# Image Namespace
+IMAGE_NAMESPACE = os.getenv("RUNTIME_SANDBOX_IMAGE_NAMESPACE", "agentscope")
+
+# Image Tag
 IMAGE_TAG = os.getenv("RUNTIME_SANDBOX_IMAGE_TAG", "latest")
-BROWSER_SESSION_ID = "123e4567-e89b-12d3-a456-426614174000"
+
+# Timeout
+TIMEOUT = int(os.getenv("RUNTIME_SANDBOX_TIMEOUT", "60"))