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

agentscope_runtime/sandbox/manager/sandbox_manager.py

@@ -4,13 +4,12 @@ import logging
 import os
 import secrets
 import inspect
-import socket
 import traceback
 
 from functools import wraps
 from typing import Optional, Dict
-from uuid import uuid4
 
+import shortuuid
 import requests
 
 from ..model import (
@@ -22,20 +21,17 @@ from ..enums import SandboxType
 from ..registry import SandboxRegistry
 from ..client import SandboxHttpClient, TrainingSandboxClient
 
-from ..manager.utils import is_port_available, sweep_port
 from ..manager.collections import (
     RedisMapping,
-    RedisSetCollection,
     RedisQueue,
     InMemoryMapping,
     InMemoryQueue,
-    InMemorySetCollection,
 )
 from ..manager.storage import (
     LocalStorage,
     OSSStorage,
 )
-from ..manager.container_clients import DockerClient
+from ..manager.container_clients import DockerClient, KubernetesClient
 from ..constant import BROWSER_SESSION_ID
 
 logging.basicConfig(level=logging.INFO)
@@ -136,32 +132,26 @@ class SandboxManager:
                 ) from e
 
             self.container_mapping = RedisMapping(redis_client)
-            self.port_set = RedisSetCollection(
-                redis_client,
-                set_name=self.config.redis_port_key,
-            )
             self.pool_queue = RedisQueue(
                 redis_client,
                 self.config.redis_container_pool_key,
             )
         else:
             self.container_mapping = InMemoryMapping()
-            self.port_set = InMemorySetCollection()
             self.pool_queue = InMemoryQueue()
 
         self.container_deployment = self.config.container_deployment
 
         if base_url is None:
             if self.container_deployment == "docker":
-                self.client = DockerClient()
+                self.client = DockerClient(config=self.config)
+            elif self.container_deployment == "k8s":
+                self.client = KubernetesClient(config=self.config)
             else:
-                # TODO: support k8s deployment
                 raise NotImplementedError("Not implemented")
         else:
             self.client = None
 
-        self.port_range = range(*self.config.port_range)
-
         self.file_system = self.config.file_system
         if self.file_system == "oss":
             self.storage = OSSStorage(
@@ -235,34 +225,6 @@ class SandboxManager:
                 logger.error(f"Error initializing runtime pool: {e}")
                 break
 
-    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
-
     @remote_wrapper()
     def cleanup(self):
         logger.debug(
@@ -414,7 +376,9 @@ class SandboxManager:
                 )
                 return None
 
-        session_id = str(uuid4())
+        alphabet = "0123456789abcdefghijklmnopqrstuvwxyz"
+        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)
@@ -439,12 +403,6 @@ class SandboxManager:
                     f"Container with name {container_name} already exists.",
                 )
 
-            free_ports = self._find_free_ports(1)
-
-            ports = {
-                "80/tcp": free_ports[0],  # nginx
-            }
-
             # Generate a random secret token
             runtime_token = secrets.token_hex(16)
 
@@ -456,17 +414,19 @@ class SandboxManager:
                 },
             }
 
-            if not self.client.create(
+            _id, ports = self.client.create(
                 image,
                 name=container_name,
-                ports=ports,
+                ports=["80/tcp"],  # Nginx
                 volumes=volume_bindings,
                 environment={
                     "SECRET_TOKEN": runtime_token,
                     **environment,
                 },
                 runtime_config=config.runtime_config,
-            ):
+            )
+
+            if _id is None:
                 return None
 
             # Check the container status
@@ -478,24 +438,22 @@ class SandboxManager:
                 )
                 return None
 
-            # Build the ContainerModel
-            container_attrs = self.client.inspect(container_name)
-
+            # TODO: update ContainerModel according to images & backend
             container_model = ContainerModel(
                 session_id=session_id,
-                container_id=container_attrs["Id"],  # Docker id pattern
+                container_id=_id,
                 container_name=container_name,
-                base_url=f"http://localhost:{ports['80/tcp']}/fastapi",
-                browser_url=f"http://localhost:{ports['80/tcp']}/steel-api"
+                base_url=f"http://localhost:{ports[0]}/fastapi",
+                browser_url=f"http://localhost:{ports[0]}/steel-api"
                 f"/{runtime_token}",
                 front_browser_ws=f"ws://localhost:"
-                f"{ports['80/tcp']}/steel-api/"
+                f"{ports[0]}/steel-api/"
                 f"{runtime_token}/v1/sessions/cast",
                 client_browser_ws=f"ws://localhost:"
-                f"{ports['80/tcp']}/steel-api/{runtime_token}/&sessionId"
+                f"{ports[0]}/steel-api/{runtime_token}/&sessionId"
                 f"={BROWSER_SESSION_ID}",
-                artifacts_sio=f"http://localhost" f":{ports['80/tcp']}/v1",
-                ports=free_ports,
+                artifacts_sio=f"http://localhost:{ports[0]}/v1",
+                ports=[ports[0]],
                 mount_dir=str(mount_dir),
                 storage_path=storage_path,
                 runtime_token=runtime_token,
@@ -537,10 +495,6 @@ class SandboxManager:
             self.client.stop(container_info.container_id, timeout=1)
             self.client.remove(container_info.container_id, force=True)
 
-            # Release ports after the container is removed
-            for port in container_info.ports:
-                self.port_set.remove(port)
-
             logger.debug(f"Container for {identity} destroyed.")
 
             # Upload to storage
@@ -570,14 +524,6 @@ class SandboxManager:
 
             container_info = ContainerModel(**container_json)
 
-            # Check whether the ports are occupied by other processes
-            for port in container_info.ports:
-                if is_port_available(port):
-                    continue
-
-                # If the port is occupied, sweep it
-                sweep_port(port)
-
             self.client.start(container_info.container_id)
             status = self.client.get_status(container_info.container_id)
             if status != "running":
@@ -685,10 +631,3 @@ class SandboxManager:
             server_configs=server_configs,
             overwrite=overwrite,
         )
-
-
-if __name__ == "__main__":
-    with SandboxManager() as manager:
-        name = manager.create("12345")
-        if name:
-            print(f"Created container: {name}")

agentscope_runtime/sandbox/manager/server/app.py

@@ -4,12 +4,14 @@ import inspect
 import logging
 import traceback
 
+from typing import Optional
+
 from fastapi import FastAPI, HTTPException, Request, Depends
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
 
-from ...manager.server.config import settings
+from ...manager.server.config import get_settings
 from ...manager.server.models import (
     ErrorResponse,
     HealthResponse,
@@ -42,34 +44,47 @@ app.add_middleware(
 security = HTTPBearer(auto_error=False)
 
 # Global SandboxManager instance
-_runtime_manager = None
-_config = SandboxManagerEnvConfig(
-    container_prefix_key=settings.CONTAINER_PREFIX_KEY,
-    file_system=settings.FILE_SYSTEM,
-    redis_enabled=settings.REDIS_ENABLED,
-    container_deployment=settings.CONTAINER_DEPLOYMENT,
-    default_mount_dir=settings.DEFAULT_MOUNT_DIR,
-    storage_folder=settings.STORAGE_FOLDER,
-    port_range=settings.PORT_RANGE,
-    pool_size=settings.POOL_SIZE,
-    oss_endpoint=settings.OSS_ENDPOINT,
-    oss_access_key_id=settings.OSS_ACCESS_KEY_ID,
-    oss_access_key_secret=settings.OSS_ACCESS_KEY_SECRET,
-    oss_bucket_name=settings.OSS_BUCKET_NAME,
-    redis_server=settings.REDIS_SERVER,
-    redis_port=settings.REDIS_PORT,
-    redis_db=settings.REDIS_DB,
-    redis_user=settings.REDIS_USER,
-    redis_password=settings.REDIS_PASSWORD,
-    redis_port_key=settings.REDIS_PORT_KEY,
-    redis_container_pool_key=settings.REDIS_CONTAINER_POOL_KEY,
-)
+_runtime_manager: Optional[SandboxManager] = None
+_config: Optional[SandboxManagerEnvConfig] = None
+
+
+def get_config() -> SandboxManagerEnvConfig:
+    """Return config"""
+    global _config
+    if _config is None:
+        settings = get_settings()
+        _config = SandboxManagerEnvConfig(
+            container_prefix_key=settings.CONTAINER_PREFIX_KEY,
+            file_system=settings.FILE_SYSTEM,
+            redis_enabled=settings.REDIS_ENABLED,
+            container_deployment=settings.CONTAINER_DEPLOYMENT,
+            default_mount_dir=settings.DEFAULT_MOUNT_DIR,
+            storage_folder=settings.STORAGE_FOLDER,
+            port_range=settings.PORT_RANGE,
+            pool_size=settings.POOL_SIZE,
+            oss_endpoint=settings.OSS_ENDPOINT,
+            oss_access_key_id=settings.OSS_ACCESS_KEY_ID,
+            oss_access_key_secret=settings.OSS_ACCESS_KEY_SECRET,
+            oss_bucket_name=settings.OSS_BUCKET_NAME,
+            redis_server=settings.REDIS_SERVER,
+            redis_port=settings.REDIS_PORT,
+            redis_db=settings.REDIS_DB,
+            redis_user=settings.REDIS_USER,
+            redis_password=settings.REDIS_PASSWORD,
+            redis_port_key=settings.REDIS_PORT_KEY,
+            redis_container_pool_key=settings.REDIS_CONTAINER_POOL_KEY,
+            k8s_namespace=settings.K8S_NAMESPACE,
+            kubeconfig_path=settings.KUBECONFIG_PATH,
+        )
+    return _config
 
 
 def verify_token(
     credentials: HTTPAuthorizationCredentials = Depends(security),
 ):
     """Verify Bearer token"""
+    settings = get_settings()
+
     if not hasattr(settings, "BEARER_TOKEN") or not settings.BEARER_TOKEN:
         logger.warning("BEARER_TOKEN not configured, skipping authentication")
         return credentials
@@ -98,8 +113,10 @@ def get_runtime_manager():
     """Get or create the global SandboxManager instance"""
     global _runtime_manager
     if _runtime_manager is None:
+        settings = get_settings()
+        config = get_config()
         _runtime_manager = SandboxManager(
-            config=_config,
+            config=config,
             default_type=settings.DEFAULT_SANDBOX_TYPE,
         )
     return _runtime_manager
@@ -159,6 +176,7 @@ async def startup_event():
 async def shutdown_event():
     """Cleanup resources on shutdown"""
     global _runtime_manager
+    settings = get_settings()
     if _runtime_manager and settings.AUTO_CLEANUP:
         _runtime_manager.cleanup()
         _runtime_manager = None
@@ -179,8 +197,21 @@ async def health_check():
 
 def main():
     """Main entry point for the Runtime Manager Service"""
+    import argparse
+    import os
     import uvicorn
 
+    parser = argparse.ArgumentParser(description="Runtime Manager Service")
+    parser.add_argument("--config", type=str, help="Path to config file")
+    args = parser.parse_args()
+
+    if args.config and not os.path.exists(args.config):
+        raise FileNotFoundError(
+            f"Error: Config file {args.config} does not exist",
+        )
+
+    settings = get_settings(args.config)
+
     uvicorn.run(
         "agentscope_runtime.sandbox.manager.server.app:app",
         host=settings.HOST,

agentscope_runtime/sandbox/manager/server/config.py

@@ -2,18 +2,9 @@
 import os
 from typing import Optional, Tuple, Literal
 from pydantic_settings import BaseSettings
-from pydantic import field_validator
+from pydantic import field_validator, ConfigDict
 from dotenv import load_dotenv
 
-env_file = ".env"
-env_example_file = ".env.example"
-
-# Load the appropriate .env file
-if os.path.exists(env_file):
-    load_dotenv(env_file)
-elif os.path.exists(env_example_file):
-    load_dotenv(env_example_file)
-
 
 class Settings(BaseSettings):
     """Runtime Manager Service Settings"""
@@ -27,11 +18,10 @@ class Settings(BaseSettings):
 
     # Runtime Manager settings
     DEFAULT_SANDBOX_TYPE: str = "base"
-    WORKDIR: str = "/workspace"
     POOL_SIZE: int = 1
     AUTO_CLEANUP: bool = True
     CONTAINER_PREFIX_KEY: str = "runtime_sandbox_container_"
-    CONTAINER_DEPLOYMENT: Literal["docker", "cloud"] = "docker"
+    CONTAINER_DEPLOYMENT: Literal["docker", "cloud", "k8s"] = "docker"
     DEFAULT_MOUNT_DIR: str = "sessions_mount_dir"
     STORAGE_FOLDER: str = "runtime_sandbox_storage"
     PORT_RANGE: Tuple[int, int] = (49152, 59152)
@@ -53,9 +43,14 @@ class Settings(BaseSettings):
     OSS_ACCESS_KEY_SECRET: str = "your-access-key-secret"
     OSS_BUCKET_NAME: str = "your-bucket-name"
 
-    class Config:
-        env_file = env_file if os.path.exists(env_file) else env_example_file
-        case_sensitive = True
+    # K8S settings
+    K8S_NAMESPACE: str = "default"
+    KUBECONFIG_PATH: Optional[str] = None
+
+    model_config = ConfigDict(
+        case_sensitive=True,
+        extra="allow",
+    )
 
     @field_validator("WORKERS", mode="before")
     @classmethod
@@ -65,4 +60,21 @@ class Settings(BaseSettings):
         return value
 
 
-settings = Settings()
+_settings: Optional[Settings] = None
+
+
+def get_settings(config_file: Optional[str] = None) -> Settings:
+    global _settings
+
+    env_file = ".env"
+    env_example_file = ".env.example"
+
+    if _settings is None:
+        if config_file and os.path.exists(config_file):
+            load_dotenv(config_file, override=True)
+        elif os.path.exists(env_file):
+            load_dotenv(env_file)
+        elif os.path.exists(env_example_file):
+            load_dotenv(env_example_file)
+        _settings = Settings()
+    return _settings

agentscope_runtime/sandbox/model/container.py

@@ -4,7 +4,6 @@ from typing import List
 from pydantic import BaseModel, Field
 
 
-# TODO: support k8s version
 class ContainerModel(BaseModel):
     session_id: str = Field(
         ...,
@@ -70,3 +69,6 @@ class ContainerModel(BaseModel):
         None,
         description="Image version of the container",
     )
+
+    class Config:
+        extra = "allow"

agentscope_runtime/sandbox/model/manager_config.py

@@ -5,10 +5,14 @@ from typing import Optional, Literal, Tuple
 from pydantic import BaseModel, Field, model_validator
 
 
+UUID_LENGTH = 25
+
+
 class SandboxManagerEnvConfig(BaseModel):
     container_prefix_key: str = Field(
         "runtime_sandbox_container_",
         description="Prefix for keys related to Container models.",
+        max_length=63 - UUID_LENGTH,  # Max length for k8s pod name
     )
 
     file_system: Literal["local", "oss"] = Field(
@@ -23,9 +27,10 @@ class SandboxManagerEnvConfig(BaseModel):
         ...,
         description="Indicates if Redis is enabled.",
     )
-    container_deployment: Literal["docker", "cloud"] = Field(
+    container_deployment: Literal["docker", "cloud", "k8s"] = Field(
         ...,
-        description="container_deployment: 'docker'.",
+        description="Container deployment backend: 'docker', 'cloud', "
+        "or 'k8s'.",
     )
 
     default_mount_dir: Optional[str] = Field(
@@ -95,6 +100,18 @@ class SandboxManagerEnvConfig(BaseModel):
         description="Prefix for Redis keys related to container pool.",
     )
 
+    # Kubernetes settings
+    k8s_namespace: Optional[str] = Field(
+        "default",
+        description="Kubernetes namespace to deploy pods. Required if "
+        "container_deployment is 'k8s'.",
+    )
+    kubeconfig_path: Optional[str] = Field(
+        None,
+        description="Path to kubeconfig file. If not set, will try "
+        "in-cluster config or default kubeconfig.",
+    )
+
     @model_validator(mode="after")
     def check_settings(cls, self):
         if not self.default_mount_dir:

agentscope_runtime/sandbox/tools/tool.py

@@ -1,5 +1,7 @@
 # -*- coding: utf-8 -*-
 # pylint: disable=unused-argument
+import inspect
+
 from abc import ABC, abstractmethod
 from typing import Optional, Any, Dict
 from ..enums import SandboxType
@@ -121,3 +123,112 @@ class Tool(ABC):
             f"sandbox_type='{self.sandbox_type}'"
             f")"
         )
+
+    def make_function(self):
+        """Create a function with proper type signatures from schema."""
+        tool_call = self.__call__
+        parameters = self.schema["function"]["parameters"]
+
+        # Extract properties and required parameters from the schema
+        properties = parameters.get("properties", {})
+        required = parameters.get("required", [])
+
+        # Type mapping from JSON schema types to Python types
+        type_mapping = {
+            "string": str,
+            "integer": int,
+            "number": float,
+            "boolean": bool,
+            "array": list,
+            "object": dict,
+        }
+
+        # Build parameter signature
+        sig_params = []
+        for param_name, param_info in properties.items():
+            param_type = type_mapping.get(
+                param_info.get("type", "string"),
+                str,
+            )
+
+            if param_name in required:
+                # Required parameter
+                param = inspect.Parameter(
+                    param_name,
+                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                    annotation=param_type,
+                )
+            else:
+                # Optional parameter with default None
+                param = inspect.Parameter(
+                    param_name,
+                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                    default=None,
+                    annotation=Optional[param_type],
+                )
+
+            sig_params.append(param)
+
+        # Create the function signature
+        new_signature = inspect.Signature(sig_params, return_annotation=Any)
+
+        def generated_function(*args, **kwargs):
+            """
+            Dynamically generated function wrapper for the tool schema.
+
+            This function is created at runtime to match the tool's parameter
+            signature as defined in the schema. It validates arguments and
+            forwards them to the tool's call interface.
+            """
+            # Bind arguments to signature
+            bound = new_signature.bind(*args, **kwargs)
+            bound.apply_defaults()
+
+            # Validate required parameters
+            missing_required = [
+                param_name
+                for param_name in required
+                if param_name not in bound.arguments
+                or bound.arguments[param_name] is None
+            ]
+
+            if missing_required:
+                raise TypeError(
+                    f"Missing required arguments: {set(missing_required)}",
+                )
+
+            # Filter kwargs based on defined properties and remove None
+            # values for optional params
+            filtered_kwargs = {
+                k: v
+                for k, v in bound.arguments.items()
+                if k in properties and (k in required or v is not None)
+            }
+
+            return tool_call(**filtered_kwargs)
+
+        # Set the correct signature and metadata
+        generated_function.__signature__ = new_signature
+        generated_function.__name__ = self.name
+
+        # Build docstring with parameter information
+        doc_parts = []
+        for name, info in properties.items():
+            required_str = " (required)" if name in required else " (optional)"
+            doc_parts.append(
+                f"    {name}: {info.get('type', 'string')}{required_str} -"
+                f" {info.get('description', '')}",
+            )
+
+        generated_function.__doc__ = (
+            self.schema["function"]["description"]
+            + "\n\nParameters:\n"
+            + "\n".join(doc_parts)
+        )
+
+        # Set type annotations for compatibility with typing inspection
+        annotations = {param.name: param.annotation for param in sig_params}
+        annotations["return"] = Any
+        generated_function.__annotations__ = annotations
+
+        return generated_function

agentscope_runtime/version.py

@@ -1,2 +1,2 @@
 # -*- coding: utf-8 -*-
-__version__ = "v0.0.1"
+__version__ = "v0.1.1"