agentscope-runtime 1.0.4a1__py3-none-any.whl → 1.0.5__py3-none-any.whl

agentscope_runtime/sandbox/manager/sandbox_manager.py

@@ -2,6 +2,8 @@
 # pylint: disable=redefined-outer-name, protected-access
 # pylint: disable=too-many-branches, too-many-statements
 # pylint: disable=redefined-outer-name, protected-access, too-many-branches
+# pylint: disable=too-many-public-methods
+import asyncio
 import inspect
 import json
 import logging
@@ -13,8 +15,13 @@ from typing import Optional, Dict, Union, List
 
 import requests
 import shortuuid
+import httpx
 
-from ..client import SandboxHttpClient, TrainingSandboxClient
+from ..client import (
+    SandboxHttpClient,
+    TrainingSandboxClient,
+    SandboxHttpAsyncClient,
+)
 from ..enums import SandboxType
 from ..manager.storage import (
     LocalStorage,
@@ -31,6 +38,8 @@ from ...common.collections import (
     InMemoryMapping,
     InMemoryQueue,
 )
+from ...common.container_clients import ContainerClientFactory
+from ..constant import TIMEOUT
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -76,6 +85,51 @@ def remote_wrapper(
     return decorator
 
 
+def remote_wrapper_async(
+    method: str = "POST",
+    success_key: str = "data",
+):
+    """
+    Async decorator to handle both remote and local method execution.
+    Supports awaitable functions.
+    """
+
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(self, *args, **kwargs):
+            # Remote mode
+            if hasattr(self, "httpx_client") and self.httpx_client is not None:
+                endpoint = "/" + func.__name__
+
+                # Build JSON data from args/kwargs
+                sig = inspect.signature(func)
+                param_names = list(sig.parameters.keys())[1:]  # Skip 'self'
+                data = dict(zip(param_names, args))
+                data.update(kwargs)
+
+                # Make async HTTP request
+                response = await self._make_request_async(
+                    method,
+                    endpoint,
+                    data,
+                )
+
+                if success_key:
+                    return response.get(success_key)
+                return response
+
+            # Local mode
+            return await func(self, *args, **kwargs)
+
+        wrapper._is_remote_wrapper = True
+        wrapper._http_method = method
+        wrapper._path = "/" + func.__name__
+
+        return wrapper
+
+    return decorator
+
+
 class SandboxManager:
     def __init__(
         self,
@@ -92,19 +146,31 @@ class SandboxManager:
             # Initialize HTTP session for remote mode with bearer token
             # authentication
             self.http_session = requests.Session()
-            self.http_session.timeout = 30
+
+            # For async HTTP
+            self.httpx_client = httpx.AsyncClient(timeout=TIMEOUT)
+
             self.base_url = base_url.rstrip("/")
             if bearer_token:
                 self.http_session.headers.update(
                     {"Authorization": f"Bearer {bearer_token}"},
                 )
+                self.httpx_client.headers.update(
+                    {"Authorization": f"Bearer {bearer_token}"},
+                )
             # Remote mode, return directly
             return
         else:
             self.http_session = None
+            self.httpx_client = None
             self.base_url = None
 
-        if not config:
+        if config:
+            logger.debug(
+                f"Launching sandbox manager with config:"
+                f"\n{config.model_dump()}",
+            )
+        else:
             config = SandboxManagerEnvConfig(
                 file_system="local",
                 redis_enabled=False,
@@ -170,30 +236,10 @@ class SandboxManager:
         self.container_deployment = self.config.container_deployment
 
         if base_url is None:
-            if self.container_deployment == "docker":
-                from ...common.container_clients.docker_client import (
-                    DockerClient,
-                )
-
-                self.client = DockerClient(config=self.config)
-            elif self.container_deployment == "k8s":
-                from ...common.container_clients.kubernetes_client import (
-                    KubernetesClient,
-                )
-
-                self.client = KubernetesClient(config=self.config)
-            elif self.container_deployment == "agentrun":
-                from ...common.container_clients.agentrun_client import (
-                    AgentRunClient,
-                )
-
-                self.client = AgentRunClient(config=self.config)
-            elif self.container_deployment == "fc":
-                from ...common.container_clients.fc_client import FCClient
-
-                self.client = FCClient(config=self.config)
-            else:
-                raise NotImplementedError("Not implemented")
+            self.client = ContainerClientFactory.create_client(
+                deployment_type=self.container_deployment,
+                config=self.config,
+            )
         else:
             self.client = None
 
@@ -226,6 +272,51 @@ class SandboxManager:
         )
         self.cleanup()
 
+        if self.http_session:
+            try:
+                self.http_session.close()
+                logger.debug("HTTP session closed.")
+            except Exception as e:
+                logger.warning(f"Error closing http_session: {e}")
+
+        if self.httpx_client:
+            try:
+                loop = asyncio.get_event_loop()
+                if loop.is_running():
+                    asyncio.ensure_future(self.httpx_client.aclose())
+                else:
+                    loop.run_until_complete(self.httpx_client.aclose())
+                logger.debug("HTTPX async client closed.")
+            except Exception as e:
+                logger.warning(f"Error closing httpx_client: {e}")
+
+    async def __aenter__(self):
+        logger.debug(
+            "Entering SandboxManager context (async). "
+            "Cleanup will be performed automatically on async exit.",
+        )
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, tb):
+        logger.debug(
+            "Exiting SandboxManager context (async). Cleaning up resources.",
+        )
+        await self.cleanup_async()
+
+        if self.http_session:
+            try:
+                self.http_session.close()
+                logger.debug("HTTP session closed.")
+            except Exception as e:
+                logger.warning(f"Error closing http_session: {e}")
+
+        if self.httpx_client:
+            try:
+                await self.httpx_client.aclose()
+                logger.debug("HTTPX async client closed.")
+            except Exception as e:
+                logger.warning(f"Error closing httpx_client: {e}")
+
     def _generate_container_key(self, session_id):
         return f"{self.prefix}{session_id}"
 
@@ -235,9 +326,14 @@ class SandboxManager:
         """
         url = f"{self.base_url}/{endpoint.lstrip('/')}"
         if method.upper() == "GET":
-            response = self.http_session.get(url, params=data)
+            response = self.http_session.get(url, params=data, timeout=TIMEOUT)
         else:
-            response = self.http_session.request(method, url, json=data)
+            response = self.http_session.request(
+                method,
+                url,
+                json=data,
+                timeout=TIMEOUT,
+            )
 
         try:
             response.raise_for_status()
@@ -274,6 +370,56 @@ class SandboxManager:
 
         return response.json()
 
+    async def _make_request_async(
+        self,
+        method: str,
+        endpoint: str,
+        data: dict,
+    ):
+        """
+        Make an asynchronous HTTP request to the specified endpoint.
+        """
+        url = f"{self.base_url}/{endpoint.lstrip('/')}"
+        if method.upper() == "GET":
+            response = await self.httpx_client.get(url, params=data)
+        else:
+            response = await self.httpx_client.request(method, url, json=data)
+
+        try:
+            response.raise_for_status()
+        except httpx.HTTPStatusError as 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()
+
     def _init_container_pool(self):
         """
         Init runtime pool
@@ -337,6 +483,11 @@ class SandboxManager:
                     f"Error cleaning up container {key}: {e}",
                 )
 
+    @remote_wrapper_async()
+    async def cleanup_async(self, *args, **kwargs):
+        """Async wrapper for cleanup()."""
+        return await asyncio.to_thread(self.cleanup, *args, **kwargs)
+
     @remote_wrapper()
     def create_from_pool(self, sandbox_type=None, meta: Optional[Dict] = None):
         """Try to get a container from runtime pool"""
@@ -444,6 +595,11 @@ class SandboxManager:
             logger.debug(f"{e}: {traceback.format_exc()}")
             return self.create()
 
+    @remote_wrapper_async()
+    async def create_from_pool_async(self, *args, **kwargs):
+        """Async wrapper for create_from_pool()."""
+        return await asyncio.to_thread(self.create_from_pool, *args, **kwargs)
+
     @remote_wrapper()
     def create(
         self,
@@ -621,6 +777,11 @@ class SandboxManager:
             self.release(identity=container_name)
             return None
 
+    @remote_wrapper_async()
+    async def create_async(self, *args, **kwargs):
+        """Async wrapper for create()."""
+        return await asyncio.to_thread(self.create, *args, **kwargs)
+
     @remote_wrapper()
     def release(self, identity):
         try:
@@ -671,6 +832,11 @@ class SandboxManager:
             logger.debug(f"{traceback.format_exc()}")
             return False
 
+    @remote_wrapper_async()
+    async def release_async(self, *args, **kwargs):
+        """Async wrapper for release()."""
+        return await asyncio.to_thread(self.release, *args, **kwargs)
+
     @remote_wrapper()
     def start(self, identity):
         try:
@@ -703,6 +869,11 @@ class SandboxManager:
             )
             return False
 
+    @remote_wrapper_async()
+    async def start_async(self, *args, **kwargs):
+        """Async wrapper for start()."""
+        return await asyncio.to_thread(self.start, *args, **kwargs)
+
     @remote_wrapper()
     def stop(self, identity):
         try:
@@ -733,11 +904,21 @@ class SandboxManager:
             )
             return False
 
+    @remote_wrapper_async()
+    async def stop_async(self, *args, **kwargs):
+        """Async wrapper for stop()."""
+        return await asyncio.to_thread(self.stop, *args, **kwargs)
+
     @remote_wrapper()
     def get_status(self, identity):
         """Get container status by container_name or container_id."""
         return self.client.get_status(identity)
 
+    @remote_wrapper_async()
+    async def get_status_async(self, *args, **kwargs):
+        """Async wrapper for get_status()."""
+        return await asyncio.to_thread(self.get_status, *args, **kwargs)
+
     @remote_wrapper()
     def get_info(self, identity):
         """Get container information by container_name or container_id."""
@@ -753,6 +934,11 @@ class SandboxManager:
 
         return container_model
 
+    @remote_wrapper_async()
+    async def get_info_async(self, *args, **kwargs):
+        """Async wrapper for get_info()."""
+        return await asyncio.to_thread(self.get_info, *args, **kwargs)
+
     def _establish_connection(self, identity):
         container_model = ContainerModel(**self.get_info(identity))
 
@@ -769,24 +955,54 @@ class SandboxManager:
             container_model,
         ).__enter__()
 
+    async def _establish_connection_async(self, identity):
+        container_model = ContainerModel(**self.get_info(identity))
+
+        # TODO: TrainingSandboxClient lacks async, can use asyncio.to_thread()
+        if (
+            "sandbox-appworld" in container_model.version
+            or "sandbox-bfcl" in container_model.version
+        ):
+            client = TrainingSandboxClient(base_url=container_model.url)
+            return client.__enter__()
+        async_client = SandboxHttpAsyncClient(container_model)
+        await async_client.__aenter__()
+        return async_client
+
     @remote_wrapper()
     def check_health(self, identity):
         """List tool"""
         client = self._establish_connection(identity)
         return client.check_health()
 
+    @remote_wrapper_async()
+    async def check_health_async(self, identity):
+        client = await self._establish_connection_async(identity)
+        return await client.check_health()
+
     @remote_wrapper()
     def list_tools(self, identity, tool_type=None, **kwargs):
         """List tool"""
         client = self._establish_connection(identity)
         return client.list_tools(tool_type=tool_type, **kwargs)
 
+    @remote_wrapper_async()
+    async def list_tools_async(self, identity, tool_type=None, **kwargs):
+        client = await self._establish_connection_async(identity)
+        return await client.list_tools(tool_type=tool_type, **kwargs)
+
     @remote_wrapper()
     def call_tool(self, identity, tool_name=None, arguments=None):
         """Call tool"""
         client = self._establish_connection(identity)
         return client.call_tool(tool_name, arguments)
 
+    @remote_wrapper_async()
+    async def call_tool_async(self, identity, tool_name=None, arguments=None):
+        """Call tool (async)"""
+        client = await self._establish_connection_async(identity)
+        return await client.call_tool(tool_name, arguments)
+
     @remote_wrapper()
     def add_mcp_servers(self, identity, server_configs, overwrite=False):
         """
@@ -798,11 +1014,36 @@ class SandboxManager:
             overwrite=overwrite,
         )
 
+    @remote_wrapper_async()
+    async def add_mcp_servers_async(
+        self,
+        identity,
+        server_configs,
+        overwrite=False,
+    ):
+        """
+        Add MCP servers to runtime (async).
+        """
+        client = await self._establish_connection_async(identity)
+        return await client.add_mcp_servers(
+            server_configs=server_configs,
+            overwrite=overwrite,
+        )
+
     @remote_wrapper()
     def get_session_mapping(self, session_ctx_id: str) -> list:
         """Get all container names bound to a session context"""
         return self.session_mapping.get(session_ctx_id) or []
 
+    @remote_wrapper_async()
+    async def get_session_mapping_async(self, *args, **kwargs):
+        """Async wrapper for get_session_mapping()."""
+        return await asyncio.to_thread(
+            self.get_session_mapping,
+            *args,
+            **kwargs,
+        )
+
     @remote_wrapper()
     def list_session_keys(self) -> list:
         """Return all session_ctx_id keys currently in mapping"""
@@ -810,3 +1051,8 @@ class SandboxManager:
         for key in self.session_mapping.scan():
             session_keys.append(key)
         return session_keys
+
+    @remote_wrapper_async()
+    async def list_session_keys_async(self, *args, **kwargs):
+        """Async wrapper for list_session_keys()."""
+        return await asyncio.to_thread(self.list_session_keys, *args, **kwargs)

agentscope_runtime/sandbox/manager/server/app.py

@@ -245,7 +245,13 @@ async def proxy_vnc_static(sandbox_id: str, path: str):
     target_url = f"{base_url}/{path}"
 
     try:
-        async with httpx.AsyncClient() as client:
+        async with httpx.AsyncClient(
+            headers={  # For FC
+                "Content-Type": "application/json",
+                "x-agentrun-session-id": "s" + sandbox_id,
+                "x-agentscope-runtime-session-id": "s" + sandbox_id,
+            },
+        ) as client:
             upstream = await client.get(target_url)
             return Response(
                 content=upstream.content,

agentscope_runtime/sandbox/manager/server/config.py

@@ -20,7 +20,7 @@ class Settings(BaseSettings):
 
     # Runtime Manager settings
     DEFAULT_SANDBOX_TYPE: Union[str, List[str]] = "base"
-    POOL_SIZE: int = 1
+    POOL_SIZE: int = 0
     AUTO_CLEANUP: bool = True
     CONTAINER_PREFIX_KEY: str = "runtime_sandbox_container_"
     CONTAINER_DEPLOYMENT: Literal[
@@ -29,6 +29,8 @@ class Settings(BaseSettings):
         "k8s",
         "agentrun",
         "fc",
+        "gvisor",
+        "boxlite",
     ] = "docker"
     DEFAULT_MOUNT_DIR: str = "sessions_mount_dir"
     # Read-only mounts (host_path -> container_path)

agentscope_runtime/sandbox/model/manager_config.py

@@ -16,15 +16,15 @@ class SandboxManagerEnvConfig(BaseModel):
     )
 
     file_system: Literal["local", "oss"] = Field(
-        ...,
+        "local",
         description="Type of file system to use: 'local' or 'oss'.",
     )
     storage_folder: Optional[str] = Field(
-        "",
+        "runtime_sandbox_storage",
         description="Folder path in storage.",
     )
     redis_enabled: bool = Field(
-        ...,
+        False,
         description="Indicates if Redis is enabled.",
     )
     container_deployment: Literal[
@@ -33,14 +33,16 @@ class SandboxManagerEnvConfig(BaseModel):
         "k8s",
         "agentrun",
         "fc",
+        "gvisor",
+        "boxlite",
     ] = Field(
-        ...,
+        "docker",
         description="Container deployment backend: 'docker', 'cloud', 'k8s'"
-        " 'agentrun' or 'fc'.",
+        " 'agentrun', 'fc', 'knative', or 'gvisor'.",
     )
 
     default_mount_dir: Optional[str] = Field(
-        None,
+        "sessions_mount_dir",
         description="Path for local file system storage.",
     )
 
@@ -67,16 +69,16 @@ class SandboxManagerEnvConfig(BaseModel):
         description="OSS endpoint URL. Required if file_system is 'oss'.",
     )
     oss_access_key_id: Optional[str] = Field(
-        None,
+        "your-access-key-id",
         description="Access key ID for OSS. Required if file_system is 'oss'.",
     )
     oss_access_key_secret: Optional[str] = Field(
-        None,
+        "your-access-key-secret",
         description="Access key secret for OSS. Required if file_system is "
         "'oss'.",
     )
     oss_bucket_name: Optional[str] = Field(
-        None,
+        "your-bucket-name",
         description="Bucket name in OSS. Required if file_system is 'oss'.",
     )
 

agentscope_runtime/tools/modelstudio_memory/__init__.py

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+"""
+ModelStudio Memory Components.
+
+This package provides components for interacting with the ModelStudio Memory
+service.
+
+Components:
+    - AddMemory: Store conversation messages as memory nodes
+    - SearchMemory: Search for relevant memories
+    - ListMemory: List memory nodes with pagination
+    - DeleteMemory: Delete a specific memory node
+    - CreateProfileSchema: Create a user profile schema
+    - GetUserProfile: Retrieve a user profile
+
+Schemas:
+    All Pydantic schemas for input/output are available in the schemas
+    submodule.
+
+Exceptions:
+    Custom exceptions for better error handling are available in the
+    exceptions submodule.
+
+Configuration:
+    Configuration can be managed through environment variables or by
+    providing a MemoryServiceConfig instance.
+"""
+
+# Configuration
+from .config import MemoryServiceConfig
+
+# Exceptions
+from .exceptions import (
+    MemoryAPIError,
+    MemoryAuthenticationError,
+    MemoryNetworkError,
+    MemoryNotFoundError,
+    MemoryValidationError,
+)
+
+# Components
+from .core import (
+    AddMemory,
+    SearchMemory,
+    ListMemory,
+    DeleteMemory,
+    CreateProfileSchema,
+    GetUserProfile,
+)
+
+# Schemas - Import commonly used schemas for convenience
+from .schemas import (
+    AddMemoryInput,
+    AddMemoryOutput,
+    CreateProfileSchemaInput,
+    CreateProfileSchemaOutput,
+    DeleteMemoryInput,
+    DeleteMemoryOutput,
+    GetUserProfileInput,
+    GetUserProfileOutput,
+    ListMemoryInput,
+    ListMemoryOutput,
+    MemoryNode,
+    Message,
+    ProfileAttribute,
+    SearchMemoryInput,
+    SearchMemoryOutput,
+    UserProfile,
+    UserProfileAttribute,
+)
+
+__all__ = [
+    # Core Components
+    "AddMemory",
+    "SearchMemory",
+    "ListMemory",
+    "DeleteMemory",
+    "CreateProfileSchema",
+    "GetUserProfile",
+    # Configuration
+    "MemoryServiceConfig",
+    # Exceptions
+    "MemoryAPIError",
+    "MemoryAuthenticationError",
+    "MemoryNetworkError",
+    "MemoryNotFoundError",
+    "MemoryValidationError",
+    # Schemas
+    "Message",
+    "MemoryNode",
+    "AddMemoryInput",
+    "AddMemoryOutput",
+    "SearchMemoryInput",
+    "SearchMemoryOutput",
+    "ListMemoryInput",
+    "ListMemoryOutput",
+    "DeleteMemoryInput",
+    "DeleteMemoryOutput",
+    "ProfileAttribute",
+    "CreateProfileSchemaInput",
+    "CreateProfileSchemaOutput",
+    "UserProfileAttribute",
+    "UserProfile",
+    "GetUserProfileInput",
+    "GetUserProfileOutput",
+]