agentscope-runtime 0.1.0__py3-none-any.whl

agentscope_runtime/sandbox/mcp_server.py

@@ -0,0 +1,192 @@
+# -*- coding: utf-8 -*-
+import argparse
+import inspect
+import logging
+
+from mcp.server.fastmcp import FastMCP
+from .box.base.base_sandbox import BaseSandbox
+from .box.browser.browser_sandbox import BrowserSandbox
+from .box.filesystem.filesystem_sandbox import FilesystemSandbox
+from .enums import SandboxType
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+mcp = FastMCP("AgentRuntime Sandbox MCP Server")
+
+
+def json_type_to_python_type(json_type: str):
+    """Convert JSON schema type to Python type annotation."""
+    type_mapping = {
+        "string": str,
+        "integer": int,
+        "number": float,
+        "boolean": bool,
+        "array": list,
+        "object": dict,
+    }
+    return type_mapping.get(json_type, str)
+
+
+def extract_content_from_mcp_response(response):
+    """Extract actual content from MCP protocol response."""
+    if isinstance(response, dict):
+        if "content" in response:
+            content = response["content"]
+            if isinstance(content, list) and len(content) > 0:
+                first_item = content[0]
+                if isinstance(first_item, dict) and "text" in first_item:
+                    return first_item["text"]
+                elif isinstance(first_item, dict) and "data" in first_item:
+                    return first_item["data"]
+            return content
+        elif "result" in response:
+            return response["result"]
+        elif "data" in response:
+            return response["data"]
+    return response
+
+
+def create_dynamic_function(schema, method_name, box):
+    """Safely create a function with dynamic signature using inspect API."""
+    func_name = schema["function"]["name"]
+    func_description = schema["function"]["description"]
+    parameters = schema["function"]["parameters"]
+    properties = parameters.get("properties", {})
+    required = parameters.get("required", [])
+
+    # Create parameter list using inspect.Parameter
+    params = []
+    for param_name, param_info in properties.items():
+        param_type = json_type_to_python_type(param_info.get("type", "string"))
+        if param_name in required:
+            param = inspect.Parameter(
+                param_name,
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                annotation=param_type,
+            )
+        else:
+            param = inspect.Parameter(
+                param_name,
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                default=None,
+                annotation=param_type,
+            )
+        params.append(param)
+
+    # Create new signature
+    new_signature = inspect.Signature(params)
+
+    # Create wrapper function
+    def wrapper(*args, **kwargs):
+        """Dynamically generated wrapper function."""
+        # Bind arguments to signature
+        try:
+            bound = new_signature.bind(*args, **kwargs)
+            bound.apply_defaults()
+        except TypeError as e:
+            raise TypeError(f"Invalid arguments for {func_name}: {e}") from e
+
+        # Filter out None values for optional parameters
+        filtered_kwargs = {
+            k: v for k, v in bound.arguments.items() if v is not None
+        }
+
+        # Call the actual method and extract content from MCP response
+        mcp_response = getattr(box, method_name)(**filtered_kwargs)
+        # Extract the actual content, not the MCP protocol wrapper
+        actual_result = extract_content_from_mcp_response(mcp_response)
+
+        return actual_result
+
+    # Set function metadata
+    wrapper.__signature__ = new_signature
+    wrapper.__name__ = func_name
+    wrapper.__doc__ = func_description
+    wrapper.__qualname__ = func_name
+    return wrapper
+
+
+def register_tools(box):
+    """Register all tools with the MCP server using FastMCP decorators."""
+    try:
+        tools_json = box.list_tools()
+
+        for server_name, tool_dict in tools_json.items():
+            logger.info(f"Registering tools from server: {server_name}")
+
+            for tool_name, tool_info in tool_dict.items():
+                json_schema = tool_info["json_schema"]
+
+                # Create dynamic function with proper signature
+                dynamic_func = create_dynamic_function(
+                    json_schema,
+                    tool_name,
+                    box,
+                )
+
+                # Apply MCP decorator
+                _ = mcp.tool(
+                    name=json_schema["function"]["name"],
+                    description=json_schema["function"]["description"],
+                )(dynamic_func)
+
+                logger.info(
+                    f"Registered tool: {json_schema['function']['name']}",
+                )
+
+    except Exception as e:
+        logger.error(f"Error registering tools: {e}")
+        raise
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Run the AgentRuntime MCP Server.",
+    )
+    parser.add_argument(
+        "--type",
+        required=False,
+        default="base",
+        choices=["base", "browser", "filesystem"],
+        help="Type of sandbox to run",
+    )
+    parser.add_argument(
+        "--base_url",
+        required=False,
+        default=None,
+        help="Base URL for the server",
+    )
+    parser.add_argument(
+        "--bearer_token",
+        required=False,
+        default=None,
+        help="Bearer token for authentication",
+    )
+
+    args = parser.parse_args()
+
+    logger.info(
+        f"Running {args.type} sandbox with base URL `{args.base_url}` and "
+        f"bearer token `{args.bearer_token}`",
+    )
+
+    sandbox_type = SandboxType(args.type)
+
+    if sandbox_type == SandboxType.BASE:
+        sandbox_cls = BaseSandbox
+    elif sandbox_type == SandboxType.BROWSER:
+        sandbox_cls = BrowserSandbox
+    elif sandbox_type == SandboxType.FILESYSTEM:
+        sandbox_cls = FilesystemSandbox
+
+    with sandbox_cls(
+        base_url=args.base_url,
+        bearer_token=args.bearer_token,
+    ) as box:
+        register_tools(box)
+        mcp.run()
+
+
+if __name__ == "__main__":
+    main()

agentscope_runtime/sandbox/model/__init__.py

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+from .container import ContainerModel
+from .manager_config import (
+    SandboxManagerEnvConfig,
+    DEFAULT_LOCAL_MANAGER_CONFIG,
+)
+
+__all__ = [
+    "ContainerModel",
+    "SandboxManagerEnvConfig",
+    "DEFAULT_LOCAL_MANAGER_CONFIG",
+]

agentscope_runtime/sandbox/model/api.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class RuntimeDiffResult(BaseModel):
+    diff: Optional[str] = Field(
+        None,
+        description="The modifications in the filesystem since the "
+        "last check.",
+    )
+    url: Optional[str] = Field(
+        None,
+        description="The current position where the browser is located.",
+    )

agentscope_runtime/sandbox/model/container.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+from typing import List
+
+from pydantic import BaseModel, Field
+
+
+# TODO: support k8s version
+class ContainerModel(BaseModel):
+    session_id: str = Field(
+        ...,
+        description="Unique identifier for the session",
+    )
+
+    container_id: str = Field(
+        ...,
+        description="Unique identifier for the container instance",
+    )
+
+    container_name: str = Field(
+        ...,
+        description="Human-readable name for the container",
+    )
+
+    base_url: str = Field(
+        ...,
+        description="Base URL for accessing the container",
+    )
+
+    browser_url: str = Field(
+        ...,
+        description="URL for browser interface within the container",
+    )
+
+    front_browser_ws: str = Field(
+        ...,
+        description="WebSocket URL for the browser used by frontend",
+    )
+
+    client_browser_ws: str = Field(
+        ...,
+        description="WebSocket URL for the browser used by runtime client",
+    )
+
+    artifacts_sio: str = Field(
+        ...,
+        description="Socketio URL for the artifacts used by frontend",
+    )
+    ports: List[int] = Field(
+        ...,
+        description="List of occupied port numbers",
+    )
+
+    mount_dir: str | None = Field(
+        None,
+        description="The mount directory of workspace.",
+    )
+
+    storage_path: str | None = Field(
+        None,
+        description="The oss_path of workspace.",
+    )
+
+    runtime_token: str | None = Field(
+        None,
+        description="Runtime token used for authentication or secure "
+        "communication",
+    )
+
+    version: str | None = Field(
+        None,
+        description="Image version of the container",
+    )

agentscope_runtime/sandbox/model/manager_config.py

@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=no-self-argument
+import os
+from typing import Optional, Literal, Tuple
+from pydantic import BaseModel, Field, model_validator
+
+
+class SandboxManagerEnvConfig(BaseModel):
+    container_prefix_key: str = Field(
+        "runtime_sandbox_container_",
+        description="Prefix for keys related to Container models.",
+    )
+
+    file_system: Literal["local", "oss"] = Field(
+        ...,
+        description="Type of file system to use: 'local' or 'oss'.",
+    )
+    storage_folder: Optional[str] = Field(
+        "",
+        description="Folder path in storage.",
+    )
+    redis_enabled: bool = Field(
+        ...,
+        description="Indicates if Redis is enabled.",
+    )
+    container_deployment: Literal["docker", "cloud"] = Field(
+        ...,
+        description="container_deployment: 'docker'.",
+    )
+
+    default_mount_dir: Optional[str] = Field(
+        None,
+        description="Path for local file system storage.",
+    )
+
+    port_range: Tuple[int, int] = Field(
+        (49152, 59152),
+        description="Range of ports to be used by the manager.",
+    )
+
+    pool_size: int = Field(
+        0,
+        description="Number of containers to be kept in the pool.",
+    )
+
+    # OSS settings
+    oss_endpoint: Optional[str] = Field(
+        "http://oss-cn-hangzhou.aliyuncs.com",
+        description="OSS endpoint URL. Required if file_system is 'oss'.",
+    )
+    oss_access_key_id: Optional[str] = Field(
+        None,
+        description="Access key ID for OSS. Required if file_system is 'oss'.",
+    )
+    oss_access_key_secret: Optional[str] = Field(
+        None,
+        description="Access key secret for OSS. Required if file_system is "
+        "'oss'.",
+    )
+    oss_bucket_name: Optional[str] = Field(
+        None,
+        description="Bucket name in OSS. Required if file_system is 'oss'.",
+    )
+
+    # Redis settings
+    redis_server: Optional[str] = Field(
+        "localhost",
+        description="Redis server address. Required if Redis is enabled.",
+    )
+    redis_port: Optional[int] = Field(
+        6379,
+        description="Port for connecting to Redis. Required if Redis is "
+        "enabled.",
+    )
+    redis_db: Optional[int] = Field(
+        0,
+        description="Database index to use in Redis. Required if Redis is "
+        "enabled.",
+    )
+    redis_user: Optional[str] = Field(
+        None,
+        description="Username for Redis authentication.",
+    )
+    redis_password: Optional[str] = Field(
+        None,
+        description="Password for Redis authentication.",
+    )
+
+    redis_port_key: str = Field(
+        "_runtime_sandbox_container_occupied_ports",
+        description="Prefix for Redis keys related to occupied ports.",
+    )
+    redis_container_pool_key: str = Field(
+        "_runtime_sandbox_container_container_pool",
+        description="Prefix for Redis keys related to container pool.",
+    )
+
+    @model_validator(mode="after")
+    def check_settings(cls, self):
+        if not self.default_mount_dir:
+            raise ValueError("default_mount_dir must be set")
+
+        os.makedirs(self.default_mount_dir, exist_ok=True)
+
+        if self.file_system == "oss":
+            required_oss_fields = [
+                self.oss_endpoint,
+                self.oss_access_key_id,
+                self.oss_access_key_secret,
+                self.oss_bucket_name,
+            ]
+            for field_name, field_value in zip(
+                [
+                    "oss_endpoint",
+                    "oss_access_key_id",
+                    "oss_access_key_secret",
+                    "oss_bucket_name",
+                ],
+                required_oss_fields,
+            ):
+                if not field_value:
+                    raise ValueError(
+                        f"{field_name} must be set when file_system is 'oss'",
+                    )
+
+        if self.redis_enabled:
+            required_redis_fields = [
+                self.redis_server,
+                self.redis_port,
+                self.redis_db,
+                self.redis_port_key,
+                self.redis_container_pool_key,
+            ]
+            for field_name, field_value in zip(
+                [
+                    "redis_server",
+                    "redis_port",
+                    "redis_db",
+                    "redis_port_key",
+                    "redis_container_pool_key",
+                ],
+                required_redis_fields,
+            ):
+                if field_value is None:
+                    raise ValueError(
+                        f"{field_name} must be set when redis is enabled",
+                    )
+
+        return self
+
+
+DEFAULT_LOCAL_MANAGER_CONFIG = SandboxManagerEnvConfig(
+    file_system="local",
+    redis_enabled=False,
+    container_deployment="docker",
+    pool_size=0,
+    default_mount_dir="sessions_mount_dir",
+)

agentscope_runtime/sandbox/registry.py

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+from typing import Dict, Type, Optional
+from dataclasses import dataclass
+
+from .enums import SandboxType
+
+
+@dataclass
+class SandboxConfig:
+    """sandbox configuration information"""
+
+    image_name: str
+    sandbox_type: SandboxType | str
+    resource_limits: Optional[Dict] = None
+    security_level: str = "medium"
+    timeout: int = 60  # Default timeout of 5 minutes
+    description: str = ""
+    environment: Optional[Dict] = None
+    runtime_config: Optional[Dict] = None
+
+    def __post_init__(self):
+        if self.runtime_config is None:
+            self.runtime_config = {}
+        if "memory" in self.resource_limits:
+            self.runtime_config["mem_limit"] = self.resource_limits["memory"]
+        if "cpu" in self.resource_limits:
+            self.runtime_config["nano_cpus"] = int(
+                float(self.resource_limits["cpu"]) * 1e9,
+            )
+
+
+class SandboxRegistry:
+    """Docker image registry for sandboxes"""
+
+    _registry: Dict[Type, SandboxConfig] = {}
+    _type_registry: Dict[SandboxType, Type] = {}
+
+    @classmethod
+    def register(
+        cls,
+        image_name: str,
+        sandbox_type: SandboxType | str,
+        resource_limits: Dict = None,
+        security_level: str = "medium",  # Not used for now
+        timeout: int = 300,
+        description: str = "",
+        environment: Dict = None,
+        runtime_config: Optional[Dict] = None,
+    ):
+        """
+        Decorator to register sandbox classes
+
+        Args:
+            image_name: Docker image name
+            sandbox_type: Sandbox type
+            resource_limits: Resource limit configuration
+            security_level: Security level (low/medium/high)
+            timeout: Timeout in seconds
+            description: Description
+            environment: Environment variables
+            runtime_config: runtime configurations
+        """
+
+        def decorator(target_class: Type) -> Type:
+            if isinstance(sandbox_type, str) and sandbox_type not in [
+                x.value for x in SandboxType
+            ]:
+                SandboxType.add_member(
+                    sandbox_type.upper(),
+                )
+
+            _sandbox_type = SandboxType(sandbox_type)
+
+            config = SandboxConfig(
+                image_name=image_name,
+                sandbox_type=_sandbox_type,
+                resource_limits=resource_limits or {},
+                security_level=security_level,
+                timeout=timeout,
+                description=description,
+                environment=environment,
+                runtime_config=runtime_config,
+            )
+
+            cls._registry[target_class] = config
+            cls._type_registry[_sandbox_type] = target_class
+
+            return target_class
+
+        return decorator
+
+    @classmethod
+    def get_config(cls, target_class: Type) -> Optional[SandboxConfig]:
+        """Get the sandbox configuration for a class"""
+        return cls._registry.get(target_class)
+
+    @classmethod
+    def get_image(cls, target_class: Type) -> Optional[str]:
+        """Get the Docker image name for a class"""
+        config = cls.get_config(target_class)
+        return config.image_name if config else None
+
+    @classmethod
+    def get_classes_by_type(cls, sandbox_type: SandboxType | str):
+        """Get all related classes by sandbox type"""
+        sandbox_type = SandboxType(sandbox_type)
+        return cls._type_registry.get(sandbox_type)
+
+    @classmethod
+    def list_all_sandboxes(cls) -> Dict[Type, SandboxConfig]:
+        """List all registered sandboxes"""
+        return cls._registry.copy()
+
+    @classmethod
+    def get_config_by_type(
+        cls,
+        sandbox_type: SandboxType | str,
+    ):
+        """Get all configurations by sandbox type"""
+        sandbox_type = SandboxType(sandbox_type)
+        cls_ = cls.get_classes_by_type(sandbox_type)
+        return cls.get_config(cls_)
+
+    @classmethod
+    def get_image_by_type(cls, sandbox_type: SandboxType | str):
+        """Get all Docker image names by sandbox type"""
+        sandbox_type = SandboxType(sandbox_type)
+        cls_ = cls.get_classes_by_type(sandbox_type)
+        return cls.get_image(cls_)

agentscope_runtime/sandbox/tools/__init__.py

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+from .sandbox_tool import SandboxTool
+from .mcp_tool import MCPTool
+from .function_tool import FunctionTool, function_tool, create_function_tool
+
+__all__ = [
+    "SandboxTool",
+    "MCPTool",
+    "FunctionTool",
+    "function_tool",
+    "create_function_tool",
+]

agentscope_runtime/sandbox/tools/base/__init__.py

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+from .tool import run_shell_command, run_ipython_cell
+
+
+__all__ = [
+    "run_shell_command",
+    "run_ipython_cell",
+]

agentscope_runtime/sandbox/tools/base/tool.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+from typing import Dict
+
+from ..sandbox_tool import SandboxTool
+
+
+class RunIPythonCellTool(SandboxTool):
+    """Tool for running IPython cells."""
+
+    _name: str = "run_ipython_cell"
+    _sandbox_type: str = "base"
+    _tool_type: str = "generic"
+    _schema: Dict = {
+        "name": "run_ipython_cell",
+        "description": "Run an IPython cell.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "code": {
+                    "type": "string",
+                    "description": "IPython code to execute",
+                },
+            },
+            "required": ["code"],
+        },
+    }
+
+
+class RunShellCommandTool(SandboxTool):
+    """Tool for running shell commands."""
+
+    _name: str = "run_shell_command"
+    _sandbox_type: str = "base"
+    _tool_type: str = "generic"
+    _schema: Dict = {
+        "name": "run_shell_command",
+        "description": "Run a shell command.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "command": {
+                    "type": "string",
+                    "description": "Shell command to execute",
+                },
+            },
+            "required": ["command"],
+        },
+    }
+
+
+run_ipython_cell = RunIPythonCellTool()
+run_shell_command = RunShellCommandTool()