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

agentscope_runtime/engine/services/session_history/__init__.py

@@ -1,6 +1,13 @@
 # -*- coding: utf-8 -*-
 from typing import TYPE_CHECKING
 from ....common.utils.lazy_loader import install_lazy_loader
+from ....common.utils.deprecation import deprecated_module
+
+deprecated_module(
+    module_name=__name__,
+    removed_in="v1.1",
+    alternative="agentscope.memory",
+)
 
 if TYPE_CHECKING:
     from .session_history_service import (

agentscope_runtime/engine/tracing/local_logging_handler.py

@@ -7,7 +7,7 @@ from datetime import datetime
 from logging.handlers import RotatingFileHandler
 from typing import Any, Dict, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
 
 from . import TracingUtil
 from .base import TracerHandler
@@ -39,8 +39,7 @@ class LogContext(BaseModel):
     ds_service_id: str = ""
     ds_service_name: str = ""
 
-    class Config:
-        extra = "ignore"  # ignore additional key
+    model_config = ConfigDict(extra="allow")
 
 
 class JsonFormatter(logging.Formatter):

agentscope_runtime/sandbox/box/sandbox.py

@@ -6,6 +6,7 @@ from typing import Any, Optional
 
 from ..enums import SandboxType
 from ..manager.sandbox_manager import SandboxManager
+from ..manager.server.app import get_config
 
 
 logging.basicConfig(level=logging.INFO)
@@ -32,12 +33,15 @@ class SandboxBase:
         self._sandbox_id = sandbox_id
 
         if base_url:
+            # Remote Manager
             self.manager_api = SandboxManager(
                 base_url=base_url,
                 bearer_token=bearer_token,
             )
         else:
+            # Embedded Manager
             self.manager_api = SandboxManager(
+                config=get_config(),
                 default_type=sandbox_type,
             )
 

agentscope_runtime/sandbox/manager/sandbox_manager.py

@@ -38,6 +38,7 @@ from ...common.collections import (
     InMemoryMapping,
     InMemoryQueue,
 )
+from ...common.container_clients import ContainerClientFactory
 from ..constant import TIMEOUT
 
 logging.basicConfig(level=logging.INFO)
@@ -164,7 +165,12 @@ class SandboxManager:
             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,
@@ -230,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
 

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",
+]

agentscope_runtime/tools/modelstudio_memory/base.py

@@ -0,0 +1,220 @@
+# -*- coding: utf-8 -*-
+"""
+Base class for ModelStudio Memory components.
+"""
+import logging
+from types import TracebackType
+from typing import Any, Dict, Optional, Type
+
+import aiohttp
+
+from .config import (
+    MemoryServiceConfig,
+)
+from .exceptions import (
+    MemoryAPIError,
+    MemoryAuthenticationError,
+    MemoryNetworkError,
+    MemoryNotFoundError,
+    MemoryValidationError,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class ModelStudioMemoryBase:
+    """
+    Base class for ModelStudio Memory API components.
+
+    This class provides common functionality for all memory components,
+    including:
+    - Configuration management
+    - HTTP request handling with error handling
+    - Common headers generation
+    - Session management
+
+    Attributes:
+        config: Configuration for the memory service
+    """
+
+    def __init__(self, config: Optional[MemoryServiceConfig] = None):
+        """
+        Initialize the base memory component.
+
+        Args:
+            config: Optional configuration. If not provided, will be loaded
+                   from environment variables.
+
+        Raises:
+            ValueError: If required configuration is missing
+        """
+        self.config = config or MemoryServiceConfig.from_env()
+        self._session: Optional[aiohttp.ClientSession] = None
+
+    def _get_headers(self) -> Dict[str, str]:
+        """
+        Get common HTTP headers for API requests.
+
+        Returns:
+            Dictionary of HTTP headers
+        """
+        return {
+            "Content-Type": "application/json",
+            "User-Agent": "agentscope-runtime",
+            "Authorization": f"Bearer {self.config.api_key}",
+        }
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        """
+        Get or create an aiohttp session.
+
+        Returns:
+            An aiohttp ClientSession
+        """
+        if self._session is None or self._session.closed:
+            self._session = aiohttp.ClientSession()
+        return self._session
+
+    async def _request(
+        self,
+        method: str,
+        url: str,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        """
+        Common HTTP request handler with comprehensive error handling.
+
+        Args:
+            method: HTTP method (GET, POST, DELETE, etc.)
+            url: Request URL
+            **kwargs: Additional arguments for the request
+
+        Returns:
+            Response JSON as dictionary
+
+        Raises:
+            MemoryAuthenticationError: If authentication fails (401)
+            MemoryNotFoundError: If resource not found (404)
+            MemoryAPIError: For other API errors
+            MemoryNetworkError: For network-related errors
+        """
+        try:
+            session = await self._get_session()
+            logger.debug(f"Making {method} request to {url}")
+
+            async with session.request(
+                method,
+                url,
+                headers=self._get_headers(),
+                **kwargs,
+            ) as response:
+                # Handle successful response
+                if response.status == 200:
+                    result = await response.json()
+                    logger.debug(
+                        f"Request successful: {method} {url}",
+                    )
+                    return result
+
+                # Handle error responses (4XX, 5XX)
+                # Try to parse JSON error response first
+                error_data = None
+                try:
+                    error_data = await response.json()
+                except Exception:
+                    # If JSON parsing fails, fall back to text
+                    error_text = await response.text()
+                    error_data = {"message": error_text}
+
+                # Extract error information
+                error_code = error_data.get("code", "Unknown")
+                error_message = error_data.get("message", "Unknown error")
+                request_id = error_data.get("request_id", "")
+
+                # Format error log
+                error_log = (
+                    f"API Error - Status: {response.status}, "
+                    f"Code: {error_code}, Message: {error_message}, "
+                    f"Request ID: {request_id}"
+                )
+                logger.error(error_log)
+
+                # Raise appropriate exception based on status code
+                if response.status in [401, 403]:
+                    raise MemoryAuthenticationError(
+                        error_message,
+                        status_code=response.status,
+                        error_code=error_code,
+                        request_id=request_id,
+                    )
+                if response.status == 404:
+                    raise MemoryNotFoundError(
+                        error_message,
+                        status_code=response.status,
+                        error_code=error_code,
+                        request_id=request_id,
+                    )
+                if response.status == 400:
+                    raise MemoryValidationError(
+                        error_message,
+                        status_code=response.status,
+                        error_code=error_code,
+                        request_id=request_id,
+                    )
+                if 400 <= response.status < 500:
+                    # Other 4XX errors
+                    raise MemoryValidationError(
+                        error_message,
+                        status_code=response.status,
+                        error_code=error_code,
+                        request_id=request_id,
+                    )
+                raise MemoryAPIError(
+                    error_message,
+                    status_code=response.status,
+                    error_code=error_code,
+                    request_id=request_id,
+                )
+
+        except aiohttp.ClientError as e:
+            logger.exception(f"Network error: {str(e)}")
+            raise MemoryNetworkError(
+                f"Network error during {method} request to {url}: {str(e)}",
+            ) from e
+        except (
+            MemoryAuthenticationError,
+            MemoryNotFoundError,
+            MemoryValidationError,
+            MemoryAPIError,
+        ):
+            # Re-raise our custom exceptions (already have proper error info)
+            raise
+        except Exception as e:
+            logger.exception(f"Unexpected error: {str(e)}")
+            raise MemoryAPIError(
+                f"Unexpected error during {method} request to {url}: {str(e)}",
+            ) from e
+
+    async def close(self) -> None:
+        """
+        Close the HTTP session.
+
+        Should be called when the component is no longer needed to clean up
+        resources.
+        """
+        if self._session and not self._session.closed:
+            await self._session.close()
+            logger.debug("Session closed")
+
+    async def __aenter__(self) -> "ModelStudioMemoryBase":
+        """Support async context manager."""
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        """Support async context manager."""
+        await self.close()

agentscope_runtime/tools/modelstudio_memory/config.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+"""
+Configuration management for ModelStudio Memory service.
+"""
+import os
+from dataclasses import dataclass
+
+
+# Default endpoint
+DEFAULT_MEMORY_SERVICE_ENDPOINT = (
+    "https://dashscope.aliyuncs.com/api/v2/apps/memory"
+)
+
+
+@dataclass
+class MemoryServiceConfig:
+    """
+    Configuration for ModelStudio Memory Service.
+
+    Attributes:
+        api_key: DashScope API key for authentication
+        service_endpoint: Base URL for the memory service API
+        service_id: Service identifier
+    """
+
+    api_key: str
+    service_endpoint: str = DEFAULT_MEMORY_SERVICE_ENDPOINT
+    service_id: str = "memory_service"
+
+    @classmethod
+    def from_env(cls) -> "MemoryServiceConfig":
+        """
+        Create configuration from environment variables.
+
+        Environment Variables:
+            DASHSCOPE_API_KEY: Required. API key for authentication
+            MEMORY_SERVICE_ENDPOINT: Optional. API endpoint URL
+            MODELSTUDIO_SERVICE_ID: Optional. Service identifier
+
+        Returns:
+            MemoryServiceConfig: Configuration instance
+
+        Raises:
+            ValueError: If DASHSCOPE_API_KEY is not set
+        """
+        api_key = os.getenv("DASHSCOPE_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "DASHSCOPE_API_KEY environment variable is required. "
+                "Please set it before using ModelStudio Memory components.",
+            )
+
+        return cls(
+            api_key=api_key,
+            service_endpoint=os.getenv(
+                "MEMORY_SERVICE_ENDPOINT",
+                DEFAULT_MEMORY_SERVICE_ENDPOINT,
+            ),
+            service_id=os.getenv("MODELSTUDIO_SERVICE_ID", "memory_service"),
+        )
+
+    def get_add_memory_url(self) -> str:
+        """Get URL for adding memory."""
+        return f"{self.service_endpoint}/add"
+
+    def get_search_memory_url(self) -> str:
+        """Get URL for searching memory."""
+        return f"{self.service_endpoint}/memory_nodes/search"
+
+    def get_list_memory_url(self) -> str:
+        """Get URL for listing memory."""
+        return f"{self.service_endpoint}/memory_nodes"
+
+    def get_delete_memory_url(self, memory_node_id: str) -> str:
+        """Get URL for deleting a specific memory node."""
+        return f"{self.service_endpoint}/memory_nodes/{memory_node_id}"
+
+    def get_create_profile_schema_url(self) -> str:
+        """Get URL for creating profile schema."""
+        return f"{self.service_endpoint}/profile_schemas"
+
+    def get_user_profile_url(self, schema_id: str) -> str:
+        """Get URL for getting user profile."""
+        return (
+            f"{self.service_endpoint}/profile_schemas/{schema_id}/user_profile"
+        )