agentscope-runtime 0.1.0__py3-none-any.whl

agentscope_runtime/engine/services/sandbox_service.py

@@ -0,0 +1,198 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=too-many-branches
+from typing import List
+
+try:
+    from ...sandbox.enums import SandboxType
+    from ...sandbox.manager import SandboxManager
+    from ...sandbox.registry import SandboxRegistry
+    from ...sandbox.tools.mcp_tool import MCPTool
+    from ...sandbox.tools.sandbox_tool import SandboxTool
+    from ...sandbox.tools.function_tool import FunctionTool
+except ImportError:
+    pass
+
+from ...engine.services.base import ServiceWithLifecycleManager
+
+
+class SandboxService(ServiceWithLifecycleManager):
+    def __init__(self, base_url=None, bearer_token=None):
+        if SandboxManager is None:
+            raise ImportError(
+                "SandboxManager is not available. "
+                "Please install agentscope-runtime[sandbox]",
+            )
+
+        self.manager_api = SandboxManager(
+            base_url=base_url,
+            bearer_token=bearer_token,
+        )
+
+        self.base_url = base_url
+        self.bearer_token = bearer_token
+        self.sandbox_type_set = set(item.value for item in SandboxType)
+
+        self.session_mapping = {}
+
+    async def start(self) -> None:
+        pass
+
+    async def stop(self) -> None:
+        # Release all environments
+        for _, env_ids in self.session_mapping.items():
+            for env_id in env_ids:
+                self.manager_api.release(env_id)
+
+        if self.base_url is None:
+            # Embedded mode
+            self.manager_api.cleanup()
+
+    async def health(self) -> bool:
+        return True
+
+    def connect(
+        self,
+        session_id,
+        user_id,
+        env_types=None,
+        tools=None,
+    ) -> List:
+        for tool in tools:
+            if not isinstance(tool, (SandboxTool, FunctionTool, MCPTool)):
+                raise ValueError(
+                    "tools must be instances of SandboxTool, FunctionTool, "
+                    "or MCPTool",
+                )
+
+        # Create a composite key
+        composite_key = self._create_composite_key(session_id, user_id)
+
+        # Check if the composite_key already has an environment
+        if composite_key in self.session_mapping:
+            # Connect to existing environment
+            return self._connect_existing_environment(composite_key)
+        else:
+            # Create a new environment
+            return self._create_new_environment(
+                composite_key,
+                env_types,
+                tools,
+            )
+
+    def _create_new_environment(
+        self,
+        composite_key,
+        env_types=None,
+        tools=None,
+    ):
+        if env_types is None:
+            assert (
+                tools is not None
+            ), "tools must be specified when env_types is not set"
+
+        server_configs = None
+        if tools:
+            server_config_list = []
+            tool_env_types = set()
+            for tool in tools:
+                tool_env_types.add(tool.sandbox_type)
+                if isinstance(tool, MCPTool):
+                    server_config_list.append(tool.server_configs)
+
+            if env_types is None:
+                env_types = []
+
+            if server_config_list:
+                server_configs = {"mcpServers": {}}
+                for server_config in server_config_list:
+                    server_configs["mcpServers"].update(
+                        server_config["mcpServers"],
+                    )
+
+            env_types = set(env_types) | tool_env_types
+
+        wbs = []
+        for env_type in env_types:
+            if env_type is None:
+                continue
+
+            box_type = SandboxType(env_type)
+
+            box_id = self.manager_api.create_from_pool(
+                sandbox_type=box_type.value,
+            )
+            box_cls = SandboxRegistry.get_classes_by_type(box_type)
+
+            box = box_cls(
+                sandbox_id=box_id,
+                base_url=self.manager_api.base_url,
+                bearer_token=self.bearer_token,
+            )
+
+            # All the operation must be done after replace this action in
+            # embedded mode
+            if self.base_url is None:
+                # Embedded mode
+                box.manager_api = self.manager_api
+
+            if box_type == SandboxType.BASE:
+                if server_configs:
+                    box.add_mcp_servers(server_configs, overwrite=False)
+
+            # Store mapping from composite_key to env_id
+            if composite_key not in self.session_mapping:
+                self.session_mapping[composite_key] = []
+
+            self.session_mapping[composite_key].append(box_id)
+
+            wbs.append(box)
+        return wbs
+
+    def _connect_existing_environment(self, composite_key):
+        env_ids = self.session_mapping.get(composite_key)
+
+        boxes = []
+        for env_id in env_ids:
+            info = self.manager_api.get_info(env_id)
+            version = info.get("version", "")
+
+            env_type = None
+            for x in SandboxType:
+                if x.value in version:
+                    env_type = x.value
+                    break
+
+            if env_type is None:
+                continue
+
+            wb_type = SandboxType(env_type)
+
+            box_cls = SandboxRegistry.get_classes_by_type(wb_type)
+
+            box = box_cls(
+                sandbox_id=env_id,
+                base_url=self.manager_api.base_url,
+                bearer_token=self.bearer_token,
+            )
+            if self.base_url is None:
+                # Embedded mode
+                box.manager_api = self.manager_api
+
+            boxes.append(box)
+
+        return boxes
+
+    def release(self, session_id, user_id):
+        composite_key = self._create_composite_key(session_id, user_id)
+
+        # Retrieve and remove env_id using composite_key
+        env_ids = self.session_mapping.pop(composite_key, [])
+
+        for env_id in env_ids:
+            self.manager_api.release(env_id)
+
+        return True
+
+    def _create_composite_key(self, session_id, user_id):
+        # Create a composite key from session_id and user_id
+        return f"{session_id}_{user_id}"

agentscope_runtime/engine/services/session_history_service.py

@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+import copy
+import uuid
+from abc import abstractmethod
+from typing import List, Dict, Optional, Union, Any
+
+from pydantic import BaseModel
+
+from .base import ServiceWithLifecycleManager
+from ..schemas.agent_schemas import Message
+
+
+class Session(BaseModel):
+    """Represents a single conversation session.
+
+    A session contains the history of a conversation, including all
+    messages, and is uniquely identified by its ID.
+
+    Attributes:
+        id: The unique identifier for the session.
+        user_id: The identifier of the user who owns the session.
+        messages: A list of messages formatted for Agent response
+
+    """
+
+    id: str
+    user_id: str
+    messages: List[Union[Message, Dict[str, Any]]] = []
+
+
+class SessionHistoryService(ServiceWithLifecycleManager):
+    """Abstract base class for session history management services.
+
+    This class defines the standard interface for creating, retrieving,
+    updating, and deleting conversation sessions. Concrete implementations
+    (like InMemorySessionHistoryService) will handle the actual storage logic.
+    """
+
+    async def start(self) -> None:
+        pass
+
+    async def stop(self) -> None:
+        pass
+
+    async def health(self) -> bool:
+        return True
+
+    @abstractmethod
+    async def create_session(
+        self,
+        user_id: str,
+        session_id: Optional[str] = None,
+    ) -> Session:
+        """Creates a new session for a given user.
+
+        Args:
+            user_id: The identifier for the user.
+            session_id: Could be defined by user
+        Returns:
+            The newly created Session object.
+        """
+
+    @abstractmethod
+    async def get_session(
+        self,
+        user_id: str,
+        session_id: str,
+    ) -> (Session | None):
+        """Retrieves a specific session.
+
+        Args:
+            user_id: The identifier for the user.
+            session_id: The identifier for the session to retrieve.
+
+        Returns:
+            The Session object if found, otherwise should raise an error or
+            return None in concrete implementations.
+        """
+
+    @abstractmethod
+    async def delete_session(self, user_id: str, session_id: str):
+        """Deletes a specific session.
+
+        Args:
+            user_id: The identifier for the user.
+            session_id: The identifier for the session to delete.
+        """
+
+    @abstractmethod
+    async def list_sessions(self, user_id: str) -> list[Session]:
+        """Lists all sessions for a given user.
+
+        Args:
+            user_id: The identifier for the user.
+
+        Returns:
+            A list of Session objects.
+        """
+        return []
+
+    async def append_message(
+        self,
+        session: Session,
+        message: Union[
+            Message,
+            List[Message],
+            Dict[str, Any],
+            List[Dict[str, Any]],
+        ],
+    ):
+        """Appends a message to the history of a specific session.
+
+        Args:
+            session: The session to which the message should be appended.
+            message: The message or list of messages to append. Supports both
+                dictionary format and Message objects.
+        """
+
+
+class InMemorySessionHistoryService(SessionHistoryService):
+    """An in-memory implementation of the SessionHistoryService.
+
+    This service stores all session data in a dictionary, making it suitable
+    for development, testing, and scenarios where persistence is not required.
+
+    Attributes:
+        _sessions: A dictionary holding all session objects, keyed by user ID
+            and then by session ID.
+    """
+
+    def __init__(self) -> None:
+        """Initializes the InMemorySessionHistoryService."""
+        self._sessions: Dict[str, Dict[str, Session]] = {}
+
+    async def create_session(
+        self,
+        user_id: str,
+        session_id: Optional[str] = None,
+    ) -> Session:
+        """Creates a new session for a given user and stores it.
+
+        Args:
+            user_id: The identifier for the user creating the session.
+            session_id: The identifier for the session to delete.
+
+        Returns:
+            A deep copy of the newly created Session object.
+        """
+        session_id = (
+            session_id.strip()
+            if session_id and session_id.strip()
+            else str(uuid.uuid4())
+        )
+        session = Session(id=session_id, user_id=user_id)
+        self._sessions.setdefault(user_id, {})[session_id] = session
+        return copy.deepcopy(session)
+
+    async def get_session(
+        self,
+        user_id: str,
+        session_id: str,
+    ) -> Session | None:
+        """Retrieves a specific session from memory.
+
+        Args:
+            user_id: The identifier for the user.
+            session_id: The identifier for the session to retrieve.
+
+        Returns:
+            A deep copy of the Session object if found, otherwise None.
+        """
+
+        session = self._sessions.get(user_id, {}).get(session_id)
+        if not session:
+            session = Session(id=session_id, user_id=user_id)
+            self._sessions.setdefault(user_id, {})[session_id] = session
+        return copy.deepcopy(session) if session else None
+
+    async def delete_session(self, user_id: str, session_id: str) -> None:
+        """Deletes a specific session from memory.
+
+        If the session does not exist, the method does nothing.
+
+        Args:
+            user_id: The identifier for the user.
+            session_id: The identifier for the session to delete.
+        """
+        if user_id in self._sessions and session_id in self._sessions[user_id]:
+            del self._sessions[user_id][session_id]
+
+    async def list_sessions(self, user_id: str) -> list[Session]:
+        """Lists all sessions for a given user.
+
+        To improve performance and reduce data transfer, the returned session
+        objects do not contain the detailed response history.
+
+        Args:
+            user_id: The identifier of the user whose sessions to list.
+
+        Returns:
+            A list of Session objects belonging to the user, without history.
+        """
+        user_sessions = self._sessions.get(user_id, {})
+        # Return sessions without their potentially large history for
+        # efficiency.
+        sessions_without_history = []
+        for session in user_sessions.values():
+            copied_session = copy.deepcopy(session)
+            copied_session.messages = []
+            sessions_without_history.append(copied_session)
+        return sessions_without_history
+
+    async def append_message(
+        self,
+        session: Session,
+        message: Union[
+            Message,
+            List[Message],
+            Dict[str, Any],
+            List[Dict[str, Any]],
+        ],
+    ) -> None:
+        """Appends message to a session's history in memory.
+
+        This method finds the authoritative session object in the in-memory
+        storage and appends the message to its history. It supports both
+        dictionary format messages and Message objects.
+
+        Args:
+            session: The session object, typically from the context. The
+                user_id and id from this object are used for lookup.
+            message: The message or list of messages to append to the
+                session's history.
+        """
+        # Normalize to list
+        if not isinstance(message, list):
+            message = [message]
+
+        norm_message = []
+        for msg in message:
+            if not isinstance(msg, Message):
+                msg = Message.model_validate(msg)
+            norm_message.append(msg)
+        session.messages.extend(norm_message)
+
+        # update the in memory copy
+        storage_session = self._sessions.get(session.user_id, {}).get(
+            session.id,
+        )
+        if storage_session:
+            storage_session.messages.extend(message)
+        else:
+            print(
+                f"Warning: Session {session.id} not found in storage for "
+                f"append_message.",
+            )

agentscope_runtime/engine/tracing/__init__.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+from typing import Any, List, Union
+
+from .base import BaseLogHandler, Tracer, TracerHandler
+from .tracing_metric import TraceType
+
+
+def create_handler(
+    eval_mode: Union[str, List] = "default",
+    **eval_params: Any,
+) -> List[TracerHandler]:
+    if isinstance(eval_mode, str):
+        eval_mode = [eval_mode]
+    handlers: List[TracerHandler] = []
+    if "default" in eval_mode:
+        handlers.append(BaseLogHandler())
+    elif "local_logging" in eval_mode:
+        from .local_logging_handler import (
+            LocalLogHandler,
+        )
+
+        handlers.append(LocalLogHandler(**eval_params))
+    return handlers
+
+
+_tracer_instances = {}
+
+
+def get_tracer(
+    eval_mode: Union[str, List] = "default",
+    **eval_params: Any,
+) -> Tracer:
+    global _tracer_instances  # noqa F824
+    if isinstance(eval_mode, str):
+        eval_mode = [eval_mode]
+    eval_mode_key = tuple(eval_mode)
+    if eval_mode_key not in _tracer_instances:
+        handlers = create_handler(eval_mode, **eval_params)
+        _tracer_instances[eval_mode_key] = Tracer(handlers)
+    return _tracer_instances[eval_mode_key]