agentscope-runtime 0.1.0__py3-none-any.whl → 0.1.2__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/build.py

@@ -124,7 +124,7 @@ def build_image(build_type, dockerfile_path=None):
             f"{free_port}:80",
             "-e",
             f"SECRET_TOKEN={secret_token}",
-            f"{image_name}",
+            f"{image_name}dev",
         ],
         capture_output=True,
         text=True,

agentscope_runtime/sandbox/custom/custom_sandbox.py

@@ -14,7 +14,6 @@ SANDBOXTYPE = "custom_sandbox"
 @SandboxRegistry.register(
     f"agentscope/runtime-sandbox-{SANDBOXTYPE}:{IMAGE_TAG}",
     sandbox_type=SANDBOXTYPE,
-    resource_limits={"memory": "16Gi", "cpu": "4"},
     security_level="medium",
     timeout=60,
     description="my sandbox",

agentscope_runtime/sandbox/custom/example.py

@@ -12,7 +12,6 @@ SANDBOX_TYPE = "example"
 @SandboxRegistry.register(
     f"agentscope/runtime-sandbox-{SANDBOX_TYPE}:{IMAGE_TAG}",
     sandbox_type=SANDBOX_TYPE,
-    resource_limits={"memory": "16Gi", "cpu": "4"},
     security_level="medium",
     timeout=60,
     description="Example sandbox",

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/__init__.py

@@ -1,8 +1,10 @@
 # -*- coding: utf-8 -*-
 from .base_client import BaseClient
 from .docker_client import DockerClient
+from .kubernetes_client import KubernetesClient
 
 __all__ = [
     "BaseClient",
     "DockerClient",
+    "KubernetesClient",
 ]

agentscope_runtime/sandbox/manager/container_clients/docker_client.py

@@ -1,16 +1,201 @@
 # -*- coding: utf-8 -*-
 import traceback
 import logging
+import platform
+import socket
+import subprocess
 
 import docker
+
 from .base_client import BaseClient
+from ..collections import RedisSetCollection, InMemorySetCollection
 
 
 logger = logging.getLogger(__name__)
 
 
+def is_port_available(port):
+    """
+    Check if a given port is available (not in use) on the local system.
+
+    Args:
+        port (int): The port number to check.
+
+    Returns:
+        bool: True if the port is available, False if it is in use.
+    """
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        try:
+            s.bind(("", port))
+            # Port is available
+            return True
+        except OSError:
+            # Port is in use
+            return False
+
+
+def sweep_port(port):
+    """Sweep all processes found listening on a given port.
+
+    Args:
+        port (int): The port number.
+
+    Returns:
+        bool: True if successful, False if failed.
+    """
+    try:
+        system = platform.system().lower()
+        if system == "windows":
+            return _sweep_port_windows(port)
+        else:
+            return _sweep_port_unix(port)
+    except Exception as e:
+        logger.error(
+            f"An error occurred while killing processes on port {port}: {e}",
+        )
+        return False
+
+
+def _sweep_port_unix(port):
+    """
+    Sweep all processes found listening on a given port.
+
+    Args:
+        port (int): The port number.
+
+    Returns:
+        int: Number of processes swept (terminated).
+    """
+    try:
+        # Use lsof to find the processes using the port
+        # TODO: support windows
+        result = subprocess.run(
+            ["lsof", "-i", f":{port}"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        # Parse the output
+        lines = result.stdout.strip().split("\n")
+        if len(lines) <= 1:
+            # No process is using the port
+            return True
+
+        # Iterate over each line (excluding the header) and kill each process
+        killed_count = 0
+        for line in lines[1:]:
+            parts = line.split()
+            if len(parts) > 1:
+                pid = parts[1]
+
+                # Kill the process using the PID
+                subprocess.run(["kill", "-9", pid], check=False)
+                killed_count += 1
+
+        if not is_port_available(port):
+            logger.warning(
+                f"Port {port} is still in use after killing processes.",
+            )
+
+        return True
+
+    except Exception as e:
+        logger.error(
+            f"An error occurred while killing processes on port {port}: {e}",
+        )
+        return False
+
+
+def _sweep_port_windows(port):
+    """
+    Windows implementation using netstat and taskkill
+    """
+    try:
+        # Use netstat to find the processes using the port
+        result = subprocess.run(
+            ["netstat", "-ano"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        # Parse the output to find processes using the specific port
+        lines = result.stdout.strip().split("\n")
+        pids_to_kill = set()
+
+        for line in lines:
+            if f":{port}" in line and "LISTENING" in line:
+                parts = line.split()
+                if len(parts) >= 5:
+                    pid = parts[-1]  # PID is usually the last column
+                    if pid.isdigit():  # Ensure it's a valid PID
+                        pids_to_kill.add(pid)
+
+        if not pids_to_kill:
+            return True
+
+        # Kill the processes
+        killed_count = 0
+        for pid in pids_to_kill:
+            try:
+                result = subprocess.run(
+                    ["taskkill", "/PID", pid, "/F"],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                )
+                if result.returncode == 0:
+                    killed_count += 1
+            except Exception as e:
+                logger.debug(f"Failed to kill process {pid}: {e}")
+                continue
+
+        if not is_port_available(port):
+            logger.warning(
+                f"Port {port} is still in use after killing processes.",
+            )
+
+        return True
+
+    except subprocess.CalledProcessError as e:
+        logger.error(f"netstat command failed: {e}")
+        return False
+    except Exception as e:
+        logger.error(f"Error in Windows port sweep: {e}")
+        return False
+
+
 class DockerClient(BaseClient):
-    def __init__(self):
+    def __init__(self, config=None):
+        self.config = config
+        self.port_range = range(*self.config.port_range)
+
+        if self.config.redis_enabled:
+            import redis
+
+            redis_client = redis.Redis(
+                host=self.config.redis_server,
+                port=self.config.redis_port,
+                db=self.config.redis_db,
+                username=self.config.redis_user,
+                password=self.config.redis_password,
+                decode_responses=True,
+            )
+            try:
+                redis_client.ping()
+            except ConnectionError as e:
+                raise RuntimeError(
+                    "Unable to connect to the Redis server.",
+                ) from e
+
+            self.port_set = RedisSetCollection(
+                redis_client,
+                set_name=self.config.redis_port_key,
+            )
+        else:
+            self.port_set = InMemorySetCollection()
+
         try:
             self.client = docker.from_env()
         except Exception as e:
@@ -32,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)
@@ -49,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(
@@ -65,17 +255,28 @@ class DockerClient(BaseClient):
         if runtime_config is None:
             runtime_config = {}
 
+        port_mapping = {}
+
+        if ports:
+            free_port = self._find_free_ports(len(ports))
+            for container_port, host_port in zip(ports, free_port):
+                port_mapping[container_port] = host_port
+
         try:
             try:
                 # Check if the image exists locally
                 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 "
@@ -86,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:
@@ -94,27 +296,28 @@ 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(
                 image,
                 detach=True,
-                ports=ports,
+                ports=port_mapping,
                 name=name,
                 volumes=volumes,
                 environment=environment,
                 **runtime_config,
             )
             container.reload()
-            return True
+            _id = container.id
+            return _id, list(port_mapping.values()), "localhost"
         except Exception as e:
             logger.error(f"An error occurred: {e}, {traceback.format_exc()}")
-            return False
+            return None, None, None
 
     def start(self, container_id):
         """Start a Docker container."""
@@ -122,6 +325,17 @@ class DockerClient(BaseClient):
             container = self.client.containers.get(
                 container_id,
             )
+
+            # Check whether the ports are occupied by other processes
+            port_mapping = container.attrs["NetworkSettings"]["Ports"]
+            for _, mappings in port_mapping.items():
+                if mappings is not None:
+                    for mapping in mappings:
+                        host_port = int(mapping["HostPort"])
+                        if is_port_available(host_port):
+                            continue
+                        sweep_port(host_port["HostPort"])
+
             container.start()
             return True
         except Exception as e:
@@ -146,7 +360,17 @@ class DockerClient(BaseClient):
             container = self.client.containers.get(
                 container_id,
             )
+            # Remove ports
+            port_mapping = container.attrs["NetworkSettings"]["Ports"]
             container.remove(force=force)
+
+            # Iterate over each port and its mappings
+            for _, mappings in port_mapping.items():
+                if mappings is not None:
+                    for mapping in mappings:
+                        host_port = int(mapping["HostPort"])
+                        self.port_set.remove(host_port)
+
             return True
         except Exception as e:
             logger.error(f"An error occurred: {e}, {traceback.format_exc()}")
@@ -168,3 +392,31 @@ class DockerClient(BaseClient):
         if container_attrs:
             return container_attrs["State"]["Status"]
         return None
+
+    def _find_free_ports(self, n):
+        free_ports = []
+
+        for port in self.port_range:
+            if len(free_ports) >= n:
+                break  # We have found enough ports
+
+            if not self.port_set.add(port):
+                continue
+
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                try:
+                    s.bind(("", port))
+                    free_ports.append(port)  # Port is available
+
+                except OSError:
+                    # Bind failed, port is in use
+                    self.port_set.remove(port)
+                    # Try the next one
+                    continue
+
+        if len(free_ports) < n:
+            raise RuntimeError(
+                "Not enough free ports available in the specified range.",
+            )
+
+        return free_ports