agentscope-runtime 0.1.0__py3-none-any.whl

agentscope_runtime/sandbox/box/filesystem/filesystem_sandbox.py

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=dangerous-default-value
+from typing import Optional
+
+from ...constant import IMAGE_TAG
+from ...registry import SandboxRegistry
+from ...enums import SandboxType
+from ...box.sandbox import Sandbox
+
+
+@SandboxRegistry.register(
+    f"agentscope/runtime-sandbox-filesystem:{IMAGE_TAG}",
+    sandbox_type=SandboxType.FILESYSTEM,
+    security_level="medium",
+    timeout=60,
+    description="Filesystem sandbox",
+)
+class FilesystemSandbox(Sandbox):
+    def __init__(
+        self,
+        sandbox_id: Optional[str] = None,
+        timeout: int = 3000,
+        base_url: Optional[str] = None,
+        bearer_token: Optional[str] = None,
+    ):
+        super().__init__(
+            sandbox_id,
+            timeout,
+            base_url,
+            bearer_token,
+            SandboxType.FILESYSTEM,
+        )
+
+    def read_file(self, path: str):
+        return self.call_tool("read_file", {"path": path})
+
+    def read_multiple_files(self, paths: list):
+        return self.call_tool("read_multiple_files", {"paths": paths})
+
+    def write_file(self, path: str, content: str):
+        return self.call_tool("write_file", {"path": path, "content": content})
+
+    def edit_file(self, path: str, edits: list, dry_run: bool = False):
+        return self.call_tool(
+            "edit_file",
+            {
+                "path": path,
+                "edits": edits,
+                "dryRun": dry_run,
+            },
+        )
+
+    def create_directory(self, path: str):
+        return self.call_tool("create_directory", {"path": path})
+
+    def list_directory(self, path: str):
+        return self.call_tool("list_directory", {"path": path})
+
+    def directory_tree(self, path: str):
+        return self.call_tool("directory_tree", {"path": path})
+
+    def move_file(self, source: str, destination: str):
+        return self.call_tool(
+            "move_file",
+            {"source": source, "destination": destination},
+        )
+
+    def search_files(
+        self,
+        path: str,
+        pattern: str,
+        exclude_patterns: list = [],
+    ):
+        return self.call_tool(
+            "search_files",
+            {
+                "path": path,
+                "pattern": pattern,
+                "excludePatterns": exclude_patterns,
+            },
+        )
+
+    def get_file_info(self, path: str):
+        return self.call_tool("get_file_info", {"path": path})
+
+    def list_allowed_directories(self):
+        return self.call_tool("list_allowed_directories", {})

agentscope_runtime/sandbox/box/sandbox.py

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+import logging
+from typing import Any, Optional
+
+from ..enums import SandboxType
+from ..manager.sandbox_manager import SandboxManager
+
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class Sandbox:
+    """
+    Sandbox Interface.
+    """
+
+    def __init__(
+        self,
+        sandbox_id: Optional[str] = None,
+        timeout: int = 3000,  # TODO: enable life circle management
+        base_url: Optional[str] = None,
+        bearer_token: Optional[str] = None,  # TODO: support api_key
+        sandbox_type: SandboxType = SandboxType.BASE,
+    ) -> None:
+        """
+        Initialize the sandbox interface.
+        """
+        if base_url:
+            self.embed_mode = False
+            self.manager_api = SandboxManager(
+                base_url=base_url,
+                bearer_token=bearer_token,
+            ).__enter__()
+        else:
+            # Launch a local manager
+            self.embed_mode = True
+            self.manager_api = SandboxManager(
+                default_type=sandbox_type,
+            )
+
+        if sandbox_id is None:
+            logger.debug(
+                "You are using embed mode, it might take several seconds to "
+                "init the runtime, please wait.",
+            )
+
+            sandbox_id = self.manager_api.create_from_pool(
+                sandbox_type=sandbox_type.value,
+            )
+            if sandbox_id is None:
+                raise RuntimeError(
+                    "No sandbox available. "
+                    "Please check if sandbox images exist, build or pull "
+                    "missing images in sandbox server.",
+                )
+            self._sandbox_id = sandbox_id
+
+        self._sandbox_id = sandbox_id
+        self.sandbox_type = sandbox_type
+        self.timeout = timeout
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        # Remote not need to close the embed_manager
+        if self.embed_mode:
+            # Clean all
+            self.manager_api.__exit__(exc_type, exc_value, traceback)
+        else:
+            # Clean the specific sandbox
+            self.manager_api.release(self.sandbox_id)
+
+    @property
+    def sandbox_id(self) -> str:
+        """Get the sandbox ID."""
+        return self._sandbox_id
+
+    @sandbox_id.setter
+    def sandbox_id(self, value: str) -> None:
+        """Set the sandbox ID."""
+        if not value:
+            raise ValueError("Sandbox ID cannot be empty.")
+        self._sandbox_id = value
+
+    def get_info(self) -> dict:
+        return self.manager_api.get_info(self.sandbox_id)
+
+    def list_tools(self, tool_type: Optional[str] = None) -> dict:
+        return self.manager_api.list_tools(
+            self.sandbox_id,
+            tool_type=tool_type,
+        )
+
+    def call_tool(
+        self,
+        name: str,
+        arguments: Optional[dict[str, Any]] = None,
+    ) -> Any:
+        if arguments is None:
+            arguments = {}
+
+        return self.manager_api.call_tool(self.sandbox_id, name, arguments)
+
+    def add_mcp_servers(
+        self,
+        server_configs: dict,
+        overwrite=False,
+    ):
+        return self.manager_api.add_mcp_servers(
+            self.sandbox_id,
+            server_configs,
+            overwrite,
+        )

agentscope_runtime/sandbox/box/shared/app.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+import logging
+
+from fastapi import FastAPI, Response, Depends
+from routers import (
+    generic_router,
+    mcp_router,
+    watcher_router,
+    workspace_router,
+)
+from dependencies import verify_secret_token
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="AgentScope Runtime Sandbox Server",
+    version="1.0",
+    description="Agentscope runtime sandbox server.",
+)
+
+
+@app.get(
+    "/healthz",
+    summary="Check the health of the API",
+    dependencies=[Depends(verify_secret_token)],
+)
+async def healthz():
+    return Response(content="OK", status_code=200)
+
+
+app.include_router(mcp_router, dependencies=[Depends(verify_secret_token)])
+app.include_router(generic_router, dependencies=[Depends(verify_secret_token)])
+app.include_router(watcher_router, dependencies=[Depends(verify_secret_token)])
+app.include_router(
+    workspace_router,
+    dependencies=[Depends(verify_secret_token)],
+)
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8000, workers=1)

agentscope_runtime/sandbox/box/shared/dependencies/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+from .deps import verify_secret_token
+
+
+__all__ = ["verify_secret_token"]

agentscope_runtime/sandbox/box/shared/dependencies/deps.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+import os
+
+from typing import Optional
+from fastapi import Header, HTTPException, status
+
+SECRET_TOKEN = os.getenv("SECRET_TOKEN", "secret_token123")
+
+
+async def verify_secret_token(authorization: Optional[str] = Header(None)):
+    if authorization is None or not authorization.startswith("Bearer "):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Missing or invalid authorization header",
+        )
+
+    token = authorization.split("Bearer ")[1]
+    if token != SECRET_TOKEN:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Invalid secret token",
+        )

agentscope_runtime/sandbox/box/shared/routers/__init__.py

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+from .generic import generic_router
+from .mcp import mcp_router
+from .runtime_watcher import watcher_router
+from .workspace import workspace_router
+
+__all__ = [
+    "mcp_router",
+    "generic_router",
+    "watcher_router",
+    "workspace_router",
+]

agentscope_runtime/sandbox/box/shared/routers/generic.py

@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+import io
+import logging
+import subprocess
+import traceback
+from contextlib import redirect_stderr, redirect_stdout
+
+from fastapi import APIRouter, Body, HTTPException
+from IPython.core.interactiveshell import InteractiveShell
+from mcp.types import CallToolResult, TextContent
+
+SPLIT_OUTPUT_MODE = True
+
+
+generic_router = APIRouter()
+
+# Initialize IPython shell
+ipy = InteractiveShell.instance()
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+@generic_router.post(
+    "/tools/run_ipython_cell",
+    summary="Invoke a cell in a stateful IPython (Jupyter) kernel",
+)
+async def run_ipython_cell(
+    code: str = Body(
+        ...,
+        example="print('Hello World')",
+        embed=True,
+    ),
+):
+    """
+    Execute code in an IPython kernel and return the results.
+    """
+    try:
+        if not code:
+            raise HTTPException(status_code=400, detail="Code is required.")
+
+        # Capture stdout and stderr separately
+        stdout_buf = io.StringIO()
+        stderr_buf = io.StringIO()
+
+        with redirect_stdout(stdout_buf), redirect_stderr(stderr_buf):
+            ipy.run_cell(code)
+
+        stdout_content = stdout_buf.getvalue()
+        stderr_content = stderr_buf.getvalue()
+
+        content_list = []
+
+        if SPLIT_OUTPUT_MODE:
+            content_list.append(
+                TextContent(
+                    type="text",
+                    text=stdout_content,
+                    description="stdout",
+                ),
+            )
+
+            if stderr_content:
+                content_list.append(
+                    TextContent(
+                        type="text",
+                        text=stderr_content,
+                        description="stderr",
+                    ),
+                )
+        else:
+            content_list.append(
+                TextContent(
+                    type="text",
+                    text=stdout_content + "\n" + stderr_content,
+                    description="output",
+                ),
+            )
+
+        is_error = bool(stderr_content)
+
+        return CallToolResult(
+            content=content_list,
+            isError=is_error,
+        ).model_dump()
+
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"{str(e)}: {traceback.format_exc()}",
+        ) from e
+
+
+@generic_router.post(
+    "/tools/run_shell_command",
+    summary="Invoke a shell command.",
+)
+async def run_shell_command(
+    command: str = Body(
+        ...,
+        example="pwd",
+        embed=True,
+    ),
+):
+    """
+    Execute a shell command and return the results.
+    """
+    try:
+        if not command:
+            raise HTTPException(status_code=400, detail="Command is required.")
+
+        result = subprocess.run(
+            command,
+            shell=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=False,
+        )
+        stdout_content = result.stdout
+        stderr_content = result.stderr
+
+        content_list = []
+
+        if SPLIT_OUTPUT_MODE:
+            content_list.append(
+                TextContent(
+                    type="text",
+                    text=stdout_content,
+                    description="stdout",
+                ),
+            )
+
+            if stderr_content:
+                content_list.append(
+                    TextContent(
+                        type="text",
+                        text=stderr_content,
+                        description="stderr",
+                    ),
+                )
+            content_list.append(
+                TextContent(
+                    type="text",
+                    text=str(result.returncode),
+                    description="returncode",
+                ),
+            )
+        else:
+            content_list.append(
+                TextContent(
+                    type="text",
+                    text=stdout_content
+                    + "\n"
+                    + stderr_content
+                    + "\n"
+                    + str(result.returncode),
+                    description="output",
+                ),
+            )
+
+        is_error = bool(stderr_content)
+
+        return CallToolResult(
+            content=content_list,
+            isError=is_error,
+        ).model_dump()
+
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"{str(e)}: {traceback.format_exc()}",
+        ) from e

agentscope_runtime/sandbox/box/shared/routers/mcp.py

@@ -0,0 +1,207 @@
+# -*- coding: utf-8 -*-
+import copy
+import json
+import logging
+import os
+import traceback
+
+from fastapi import APIRouter, Body, HTTPException, Response
+
+from .mcp_utils import MCPSessionHandler
+
+mcp_router = APIRouter()
+
+_MCP_SERVERS = {}
+current_directory = os.path.dirname(os.path.abspath(__file__))
+mcp_server_configs_path = os.path.abspath(
+    os.path.join(current_directory, "../mcp_server_configs.json"),
+)
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+# NOTE: DO NOT use API-KEY Server in release version due to security issues
+@mcp_router.post(
+    "/mcp/add_servers",
+    summary="Add and initialize MCP servers",
+)
+async def add_servers(
+    server_configs: dict = Body(
+        {},
+        embed=True,
+    ),
+    overwrite: bool = Body(
+        False,
+        embed=True,
+    ),
+):
+    global _MCP_SERVERS
+
+    try:
+        if not server_configs:
+            raise HTTPException(
+                status_code=400,
+                detail="server_configs is required.",
+            )
+
+        new_servers = [
+            MCPSessionHandler(name, config)
+            for name, config in server_configs["mcpServers"].items()
+        ]
+
+        fail_servers = []
+
+        # Initialize the servers
+        for server in new_servers:
+            if server.name in _MCP_SERVERS:
+                if not overwrite:
+                    continue
+                # Cleanup old server
+                await _MCP_SERVERS.pop(server.name).cleanup()
+            try:
+                await server.initialize()
+                _MCP_SERVERS[server.name] = server
+            except Exception as e:
+                logging.error(f"Failed to initialize server: {e}")
+                fail_servers.append(server)
+                continue
+
+        if fail_servers:
+            for server in fail_servers:
+                await server.cleanup()
+            raise HTTPException(
+                status_code=500,
+                detail=f"Failed to initialize server: "
+                f"{[server.name for server in fail_servers]}",
+            )
+        return Response(content="OK", status_code=200)
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"{str(e)}: {traceback.format_exc()}",
+        ) from e
+
+
+@mcp_router.get(
+    "/mcp/list_tools",
+    summary="List MCP tools",
+)
+async def list_tools():
+    try:
+        mcp_tools = {}
+
+        for server_name, server in _MCP_SERVERS.items():
+            tools = await server.list_tools()
+            server_tools = {}
+            for tool in tools:
+                name = tool.name
+                if name in server_tools:
+                    logging.warning(
+                        f"Service function `{name}` already exists, "
+                        f"skip adding it.",
+                    )
+                else:
+                    json_schema = {
+                        "type": "function",
+                        "function": {
+                            "name": tool.name,
+                            "description": tool.description,
+                            "parameters": {
+                                "type": "object",
+                                "properties": tool.inputSchema.get(
+                                    "properties",
+                                    {},
+                                ),
+                                "required": tool.inputSchema.get(
+                                    "required",
+                                    [],
+                                ),
+                            },
+                        },
+                    }
+                    server_tools[tool.name] = {
+                        "name": tool.name,
+                        "json_schema": json_schema,
+                    }
+            mcp_tools[server_name] = copy.deepcopy(server_tools)
+        return mcp_tools
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"{str(e)}: {traceback.format_exc()}",
+        ) from e
+
+
+@mcp_router.post(
+    "/mcp/call_tool",
+    summary="Execute MCP tool",
+)
+async def call_tool(
+    tool_name: str = Body(
+        ...,
+        embed=True,
+    ),
+    arguments: dict = Body(
+        {},
+        embed=True,
+    ),
+) -> None:
+    try:
+        if not tool_name:
+            raise HTTPException(
+                status_code=400,
+                detail="tool_name is required.",
+            )
+
+        tools = await list_tools()
+        for server_name, server_tools in tools.items():
+            if tool_name not in server_tools:
+                continue
+            server = _MCP_SERVERS[server_name]
+            result = await server.call_tool(tool_name, arguments)
+            return result.model_dump()
+        raise ModuleNotFoundError(f"Tool '{tool_name}' not found.")
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"{str(e)}: {traceback.format_exc()}",
+        ) from e
+
+
+@mcp_router.on_event("shutdown")
+async def cleanup_servers() -> None:
+    """Clean up all servers properly."""
+    global _MCP_SERVERS
+
+    for server in reversed(list(_MCP_SERVERS.values())):
+        try:
+            await server.cleanup()
+        except Exception as e:
+            logging.error(f"Failed to cleanup server: {e}")
+
+    _MCP_SERVERS = {}
+
+
+@mcp_router.on_event("startup")
+async def startup_event():
+    # Load MCP server configs
+    try:
+        with open(mcp_server_configs_path, "r", encoding="utf-8") as file:
+            mcp_server_configs = json.load(file)
+
+    except Exception as e:
+        logger.error(f"Failed to load MCP server configs: {e}")
+        mcp_server_configs = {}
+
+    # Call the add_servers function
+    if mcp_server_configs:
+        try:
+            await add_servers(
+                server_configs=mcp_server_configs,
+                overwrite=False,
+            )
+        except Exception as e:
+            logger.error(
+                f"Failed to add MCP servers: {e}, {traceback.format_exc()}",
+            )