agentscope-runtime 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

agentscope_runtime/sandbox/box/training_box/training_box.py

@@ -7,6 +7,7 @@ with specific configuration and tool calling methods.
 """
 import platform
 from typing import Dict, Optional
+import os
 
 from ...registry import SandboxRegistry
 from ...enums import SandboxType
@@ -21,14 +22,6 @@ def get_image_tag() -> str:
     return IMAGE_TAG
 
 
-@SandboxRegistry.register(
-    f"agentscope/runtime-sandbox-appworld:{get_image_tag()}",
-    sandbox_type=SandboxType.APPWORLD,
-    runtime_config={"shm_size": "5.06gb"},
-    security_level="medium",
-    timeout=30,
-    description="appworld Sandbox",
-)
 class TrainingSandbox(Sandbox):
     """
     Training Sandbox class for managing and executing training-related tasks.
@@ -43,6 +36,7 @@ class TrainingSandbox(Sandbox):
         timeout: int = 3000,
         base_url: Optional[str] = None,
         bearer_token: Optional[str] = None,
+        box_type: SandboxType = SandboxType.APPWORLD,
     ):
         """
         Initialize the Training Sandbox.
@@ -58,7 +52,7 @@ class TrainingSandbox(Sandbox):
             timeout,
             base_url,
             bearer_token,
-            SandboxType.APPWORLD,
+            box_type,
         )
 
     def create_instance(
@@ -217,3 +211,139 @@ class TrainingSandbox(Sandbox):
                 "instance_id": instance_id,
             },
         )
+
+
+@SandboxRegistry.register(
+    f"agentscope/runtime-sandbox-appworld:{get_image_tag()}",
+    sandbox_type=SandboxType.APPWORLD,
+    runtime_config={"shm_size": "5.06gb"},
+    security_level="medium",
+    timeout=30,
+    description="appworld Sandbox",
+)
+class APPWorldSandbox(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.APPWORLD,
+        )
+
+
+DATASET_SUB_TYPE = os.environ.get("DATASET_SUB_TYPE", "multi_turn")
+
+
+@SandboxRegistry.register(
+    f"agentscope/runtime-sandbox-bfcl:{get_image_tag()}",
+    sandbox_type=SandboxType.BFCL,
+    runtime_config={"shm_size": "8.06gb"},
+    security_level="medium",
+    environment={
+        "OPENAI_API_KEY": os.environ.get("OPENAI_API_KEY", ""),
+        "BFCL_DATA_PATH": f"/agentscope_runtime/training_box/bfcl/multi_turn/"
+        f"{DATASET_SUB_TYPE}_processed.jsonl",
+        "BFCL_SPLID_ID_PATH": f"/agentscope_runtime/training_box/"
+        f"bfcl/multi_turn/"
+        f"{DATASET_SUB_TYPE}_split_ids.json",
+    },
+    # ["all","all_scoring","multi_turn","single_turn",
+    # "live","non_live","non_python","python"]
+    timeout=30,
+    description="bfcl Sandbox",
+)
+class BFCLSandbox(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,
+        )
+
+
+@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,
+        )

agentscope_runtime/sandbox/client/http_client.py

@@ -195,7 +195,7 @@ class SandboxHttpClient:
             mcp_tools = response.json()
             mcp_tools["generic"] = self.generic_tools
             if tool_type:
-                return {tool_type: mcp_tools.get(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}")

agentscope_runtime/sandbox/enums.py

@@ -66,3 +66,5 @@ class SandboxType(DynamicEnum):
     BROWSER = "browser"
     FILESYSTEM = "filesystem"
     APPWORLD = "appworld"
+    BFCL = "bfcl"
+    WEBSHOP = "webshop"

agentscope_runtime/sandbox/manager/container_clients/docker_client.py

@@ -217,9 +217,12 @@ class DockerClient(BaseClient):
             acr_registry = "agentscope-registry.ap-southeast-1.cr.aliyuncs.com"
             acr_image = f"{acr_registry}/{image}"
 
-            logger.debug(f"Attempting to pull from ACR: {acr_image}")
+            logger.info(
+                f"Attempting to pull from ACR: {acr_image}, it might take "
+                f"several minutes.",
+            )
             self.client.images.pull(acr_image)
-            logger.debug(f"Successfully pulled image from ACR: {acr_image}")
+            logger.info(f"Successfully pulled image from ACR: {acr_image}")
 
             # Retag the image
             acr_img_obj = self.client.images.get(acr_image)
@@ -234,7 +237,9 @@ class DockerClient(BaseClient):
                 logger.debug(f"Failed to remove original tag: {e}")
             return True
         except Exception as e:
-            logger.error(f"Failed to pull from ACR: {e}")
+            logger.error(
+                f"Failed to pull from ACR: {e}, {traceback.format_exc()}",
+            )
             return False
 
     def create(
@@ -263,11 +268,15 @@ class DockerClient(BaseClient):
                 self.client.images.get(image)
                 logger.debug(f"Image '{image}' found locally.")
             except docker.errors.ImageNotFound:
-                logger.debug(
+                logger.info(
                     f"Image '{image}' not found locally. "
                     f"Attempting to pull it...",
                 )
                 try:
+                    logger.info(
+                        f"Attempting to pull: {image}, "
+                        f"it might take several minutes.",
+                    )
                     self.client.images.pull(image)
                     logger.debug(
                         f"Image '{image}' successfully pulled from default "
@@ -278,7 +287,8 @@ class DockerClient(BaseClient):
                     logger.warning(
                         f"Failed to pull from default registry: {e}",
                     )
-                    logger.debug("Trying to pull from ACR fallback...")
+                    logger.warning("Trying to pull from ACR fallback...")
+
                     pull_success = self._try_pull_from_acr(image)
 
                 if not pull_success:
@@ -286,11 +296,11 @@ class DockerClient(BaseClient):
                         f"Failed to pull image '{image}' from both "
                         f"default and ACR",
                     )
-                    return False
+                    return None, None, None
 
             except docker.errors.APIError as e:
                 logger.error(f"Error occurred while checking the image: {e}")
-                return False
+                return None, None, None
 
             # Create and run the container
             container = self.client.containers.run(
@@ -304,10 +314,10 @@ class DockerClient(BaseClient):
             )
             container.reload()
             _id = container.id
-            return _id, list(port_mapping.values())
+            return _id, list(port_mapping.values()), "localhost"
         except Exception as e:
             logger.error(f"An error occurred: {e}, {traceback.format_exc()}")
-            return None, None
+            return None, None, None
 
     def start(self, container_id):
         """Start a Docker container."""

agentscope_runtime/sandbox/manager/container_clients/kubernetes_client.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 # pylint: disable=too-many-branches
+import os
 import time
 import hashlib
 import traceback
@@ -89,7 +90,9 @@ class KubernetesClient(BaseClient):
             runtime_config = {}
 
         container_name = name or "main-container"
+
         # Container specification
+        # TODO: use image from docker registry first
         container = client.V1Container(
             name=container_name,
             image=f"agentscope-registry.ap-southeast-1.cr.aliyuncs.com"
@@ -244,6 +247,7 @@ class KubernetesClient(BaseClient):
             )
 
             exposed_ports = []
+            pod_node_ip = "localhost"
             # Auto-create services for exposed ports (like Docker's port
             # mapping)
             if ports:
@@ -259,19 +263,22 @@ class KubernetesClient(BaseClient):
                         parsed_ports,
                     )
                     if service_created:
-                        exposed_ports = self._get_service_node_ports(name)
+                        (
+                            exposed_ports,
+                            pod_node_ip,
+                        ) = self._get_service_node_ports(name)
             logger.debug(
                 f"Pod '{name}' created with exposed ports: {exposed_ports}",
             )
 
             if not self.wait_for_pod_ready(name, timeout=60):
                 logger.error(f"Pod '{name}' failed to become ready")
-                return None, None
+                return None, None, None
 
-            return name, exposed_ports
+            return name, exposed_ports, pod_node_ip
         except Exception as e:
             logger.error(f"An error occurred: {e}, {traceback.format_exc()}")
-            return None, None
+            return None, None, None
 
     def start(self, container_id):
         """
@@ -510,7 +517,10 @@ class KubernetesClient(BaseClient):
             service = client.V1Service(
                 api_version="v1",
                 kind="Service",
-                metadata=client.V1ObjectMeta(name=service_name),
+                metadata=client.V1ObjectMeta(
+                    name=service_name,
+                    namespace=self.namespace,
+                ),
                 spec=service_spec,
             )
 
@@ -540,11 +550,56 @@ class KubernetesClient(BaseClient):
             )
 
             node_ports = []
+            pod_node_ip = self._get_pod_node_ip(pod_name)
+
             for port in service_info.spec.ports:
                 if port.node_port:
                     node_ports.append(port.node_port)
 
-            return node_ports
+            return node_ports, pod_node_ip
         except Exception as e:
             logger.error(f"Failed to get node port: {e}")
             return None
+
+    def _get_pod_node_ip(self, pod_name):
+        """Get the IP of the node where the pod is running"""
+
+        # Check if we are running in Colima, where pod runs in VM
+        docker_host = os.getenv("DOCKER_HOST", "")
+        if "colima" in docker_host.lower():
+            return "localhost"
+
+        try:
+            pod = self.v1.read_namespaced_pod(
+                name=pod_name,
+                namespace=self.namespace,
+            )
+
+            node_name = pod.spec.node_name
+            if not node_name:
+                logger.warning(
+                    f"Pod {pod_name} is not scheduled to any node yet",
+                )
+                return None
+
+            node = self.v1.read_node(name=node_name)
+
+            external_ip = None
+            internal_ip = None
+
+            for address in node.status.addresses:
+                if address.type == "ExternalIP":
+                    external_ip = address.address
+                elif address.type == "InternalIP":
+                    internal_ip = address.address
+
+            result_ip = external_ip or internal_ip
+            logger.debug(
+                f"Using IP: {result_ip} (external: {external_ip}, internal:"
+                f" {internal_ip})",
+            )
+            return result_ip
+
+        except Exception as e:
+            logger.error(f"Failed to get pod node IP: {e}")
+            return None

agentscope_runtime/sandbox/manager/sandbox_manager.py

@@ -2,12 +2,14 @@
 # pylint: disable=redefined-outer-name, protected-access, too-many-branches
 import logging
 import os
+import json
 import secrets
 import inspect
 import traceback
 
 from functools import wraps
 from typing import Optional, Dict
+from urllib.parse import urlparse, urlunparse
 
 import shortuuid
 import requests
@@ -15,7 +17,6 @@ import requests
 from ..model import (
     ContainerModel,
     SandboxManagerEnvConfig,
-    DEFAULT_LOCAL_MANAGER_CONFIG,
 )
 from ..enums import SandboxType
 from ..registry import SandboxRegistry
@@ -81,7 +82,7 @@ def remote_wrapper(
 class SandboxManager:
     def __init__(
         self,
-        config: SandboxManagerEnvConfig = DEFAULT_LOCAL_MANAGER_CONFIG,
+        config: Optional[SandboxManagerEnvConfig] = None,
         base_url=None,
         bearer_token=None,
         default_type: SandboxType | str = SandboxType.BASE,
@@ -96,19 +97,28 @@ class SandboxManager:
                 self.http_session.headers.update(
                     {"Authorization": f"Bearer {bearer_token}"},
                 )
+            # Remote mode, return directly
+            return
         else:
             self.http_session = None
             self.base_url = None
 
+        if not config:
+            config = SandboxManagerEnvConfig(
+                file_system="local",
+                redis_enabled=False,
+                container_deployment="docker",
+                pool_size=0,
+                default_mount_dir="sessions_mount_dir",
+            )
+
         self.default_type = SandboxType(default_type)
         self.workdir = "/workspace"
 
         self.config = config
         self.pool_size = self.config.pool_size
         self.prefix = self.config.container_prefix_key
-        self.default_mount_dir = (
-            self.config.default_mount_dir or "sessions_mount_dir"
-        )
+        self.default_mount_dir = self.config.default_mount_dir
         self.storage_folder = (
             self.config.storage_folder or self.default_mount_dir
         )
@@ -197,8 +207,35 @@ class SandboxManager:
         try:
             response.raise_for_status()
         except requests.exceptions.HTTPError as e:
-            logger.error(f"Error making request: {e}")
-            return {"data": f"Error: {e}"}
+            error_components = [
+                f"HTTP {response.status_code} Error: {str(e)}",
+            ]
+
+            try:
+                server_response = response.json()
+                if "detail" in server_response:
+                    error_components.append(
+                        f"Server Detail: {server_response['detail']}",
+                    )
+                elif "error" in server_response:
+                    error_components.append(
+                        f"Server Error: {server_response['error']}",
+                    )
+                else:
+                    error_components.append(
+                        f"Server Response: {server_response}",
+                    )
+            except (ValueError, json.JSONDecodeError):
+                if response.text:
+                    error_components.append(
+                        f"Server Response: {response.text}",
+                    )
+
+            error = " | ".join(error_components)
+
+            logger.error(f"Error making request: {error}")
+
+            return {"data": f"Error: {error}"}
 
         return response.json()
 
@@ -380,20 +417,24 @@ class SandboxManager:
         short_uuid = shortuuid.ShortUUID(alphabet=alphabet).uuid()
         session_id = str(short_uuid)
 
-        if mount_dir is None:
-            mount_dir = os.path.join(self.default_mount_dir, session_id)
-            os.makedirs(mount_dir, exist_ok=True)
+        if not mount_dir:
+            if self.default_mount_dir:
+                mount_dir = os.path.join(self.default_mount_dir, session_id)
+                os.makedirs(mount_dir, exist_ok=True)
 
-        if not os.path.isabs(mount_dir):
-            mount_dir = os.path.abspath(mount_dir)
+        if mount_dir:
+            if not os.path.isabs(mount_dir):
+                mount_dir = os.path.abspath(mount_dir)
 
         if storage_path is None:
-            storage_path = self.storage.path_join(
-                self.storage_folder,
-                session_id,
-            )
+            if self.storage_folder:
+                storage_path = self.storage.path_join(
+                    self.storage_folder,
+                    session_id,
+                )
 
-        self.storage.download_folder(storage_path, mount_dir)
+        if mount_dir and storage_path:
+            self.storage.download_folder(storage_path, mount_dir)
 
         try:
             # Check for an existing container with the same name
@@ -407,14 +448,17 @@ class SandboxManager:
             runtime_token = secrets.token_hex(16)
 
             # Prepare volume bindings if a mount directory is provided
-            volume_bindings = {
-                mount_dir: {
-                    "bind": self.workdir,
-                    "mode": "rw",
-                },
-            }
+            if mount_dir:
+                volume_bindings = {
+                    mount_dir: {
+                        "bind": self.workdir,
+                        "mode": "rw",
+                    },
+                }
+            else:
+                volume_bindings = {}
 
-            _id, ports = self.client.create(
+            _id, ports, ip = self.client.create(
                 image,
                 name=container_name,
                 ports=["80/tcp"],  # Nginx
@@ -443,16 +487,16 @@ class SandboxManager:
                 session_id=session_id,
                 container_id=_id,
                 container_name=container_name,
-                base_url=f"http://localhost:{ports[0]}/fastapi",
-                browser_url=f"http://localhost:{ports[0]}/steel-api"
+                base_url=f"http://{ip}:{ports[0]}/fastapi",
+                browser_url=f"http://{ip}:{ports[0]}/steel-api"
                 f"/{runtime_token}",
-                front_browser_ws=f"ws://localhost:"
+                front_browser_ws=f"ws://{ip}:"
                 f"{ports[0]}/steel-api/"
                 f"{runtime_token}/v1/sessions/cast",
-                client_browser_ws=f"ws://localhost:"
+                client_browser_ws=f"ws://{ip}:"
                 f"{ports[0]}/steel-api/{runtime_token}/&sessionId"
                 f"={BROWSER_SESSION_ID}",
-                artifacts_sio=f"http://localhost:{ports[0]}/v1",
+                artifacts_sio=f"http://{ip}:{ports[0]}/v1",
                 ports=[ports[0]],
                 mount_dir=str(mount_dir),
                 storage_path=storage_path,
@@ -498,10 +542,11 @@ class SandboxManager:
             logger.debug(f"Container for {identity} destroyed.")
 
             # Upload to storage
-            self.storage.upload_folder(
-                container_info.mount_dir,
-                container_info.storage_path,
-            )
+            if container_info.mount_dir and container_info.storage_path:
+                self.storage.upload_folder(
+                    container_info.mount_dir,
+                    container_info.storage_path,
+                )
 
             return True
         except Exception as e:
@@ -599,9 +644,24 @@ class SandboxManager:
         enable_browser = "browser" in container_model.version
 
         # TODO: remake docker name
-        if "appworld" in container_model.version:
+        if (
+            "sandbox-appworld" in container_model.version
+            or "sandbox-bfcl" in container_model.version
+        ):
+            parsed = urlparse(container_model.base_url)
+            base_url = urlunparse(
+                (
+                    parsed.scheme,
+                    parsed.netloc,
+                    "",
+                    "",
+                    "",
+                    "",
+                ),
+            )
+
             return TrainingSandboxClient(
-                base_url=f"http://localhost:{container_model.ports[0]}",
+                base_url=base_url,
             ).__enter__()
 
         return SandboxHttpClient(