agentscope-runtime 0.1.0__py3-none-any.whl

agentscope_runtime/engine/services/context_manager.py

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+from contextlib import asynccontextmanager
+from typing import List
+
+from .manager import ServiceManager
+from .memory_service import MemoryService, InMemoryMemoryService
+from .session_history_service import (
+    SessionHistoryService,
+    Session,
+    InMemorySessionHistoryService,
+)
+from ..schemas.agent_schemas import Message
+
+
+class ContextComposer:
+    @staticmethod
+    async def compose(
+        request_input: List[Message],  # current input
+        session: Session,  # session
+        memory_service: MemoryService = None,
+        session_history_service: SessionHistoryService = None,
+    ):
+        # session
+        if session_history_service:
+            await session_history_service.append_message(
+                session=session,
+                message=request_input,
+            )
+        else:
+            session.messages += request_input
+        # memory
+        if memory_service:
+            memories: List[Message] = await memory_service.search_memory(
+                user_id=session.user_id,
+                messages=request_input,
+                filters={"top_k": 5},
+            )
+            await memory_service.add_memory(
+                user_id=session.user_id,
+                messages=request_input,
+                session_id=session.id,
+            )
+            session.messages = memories + session.messages
+
+
+class ContextManager(ServiceManager):
+    """
+    The contextManager class
+    """
+
+    def __init__(
+        self,
+        context_composer_cls=ContextComposer,
+        session_history_service: SessionHistoryService = None,
+        memory_service: MemoryService = None,
+    ):
+        self._context_composer_cls = context_composer_cls
+        self._session_history_service = session_history_service
+        self._memory_service = memory_service
+        super().__init__()
+
+    def _register_default_services(self):
+        """Register default services for context management."""
+        self._session_history_service = (
+            self._session_history_service or InMemorySessionHistoryService()
+        )
+        self._memory_service = self._memory_service or InMemoryMemoryService()
+
+        self.register_service("session", self._session_history_service)
+        self.register_service("memory", self._memory_service)
+
+    async def compose_context(
+        self,
+        session: Session,
+        request_input: List[Message],
+    ):
+        await self._context_composer_cls.compose(
+            memory_service=self._memory_service,
+            session_history_service=self._session_history_service,
+            session=session,
+            request_input=request_input,
+        )
+
+    async def compose_session(
+        self,
+        user_id: str,
+        session_id: str,
+    ):
+        if self._session_history_service:
+            session = await self._session_history_service.get_session(
+                user_id=user_id,
+                session_id=session_id,
+            )
+            if not session:
+                raise RuntimeError(f"Session {session_id} not found")
+        else:
+            session = Session(
+                user_id=user_id,
+                id=session_id,
+                messages=[],
+            )
+        return session
+
+    async def append(self, session: Session, event_output: List[Message]):
+        if self._session_history_service:
+            await self._session_history_service.append_message(
+                session=session,
+                message=event_output,
+            )
+        if self._memory_service:
+            await self._memory_service.add_memory(
+                user_id=session.user_id,
+                session_id=session.id,
+                messages=event_output,
+            )
+
+
+@asynccontextmanager
+async def create_context_manager(
+    memory_service: MemoryService = None,
+    session_history_service: SessionHistoryService = None,
+):
+    manager = ContextManager(
+        memory_service=memory_service,
+        session_history_service=session_history_service,
+    )
+
+    async with manager:
+        yield manager

agentscope_runtime/engine/services/environment_manager.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+from typing import List
+from contextlib import asynccontextmanager
+
+from .manager import ServiceManager
+from .sandbox_service import SandboxService
+
+
+class EnvironmentManager(ServiceManager):
+    """
+    The EnvironmentManager class for managing environment-related services.
+    """
+
+    def __init__(self, sandbox_service: SandboxService = None):
+        self._sandbox_service = sandbox_service
+        super().__init__()
+
+    def _register_default_services(self):
+        """Register default services for environment management."""
+        self._sandbox_service = self._sandbox_service or SandboxService()
+        self.register_service("sandbox", self._sandbox_service)
+
+    def connect_sandbox(
+        self,
+        session_id,
+        user_id,
+        env_types=None,
+        tools=None,
+    ) -> List:
+        return self._sandbox_service.connect(
+            session_id,
+            user_id,
+            env_types=env_types,
+            tools=tools,
+        )
+
+    def release_sandbox(self, session_id, user_id):
+        return self._sandbox_service.release(session_id, user_id)
+
+
+@asynccontextmanager
+async def create_environment_manager(
+    sandbox_service: SandboxService = None,
+):
+    manager = EnvironmentManager(
+        sandbox_service=sandbox_service,
+    )
+
+    async with manager:
+        yield manager

agentscope_runtime/engine/services/manager.py

@@ -0,0 +1,174 @@
+# -*- coding: utf-8 -*-
+import logging
+from contextlib import AsyncExitStack
+from typing import Dict, Any, Type, List
+from abc import ABC, abstractmethod
+
+from agentscope_runtime.engine import Service
+
+logger = logging.getLogger(__name__)
+
+
+class ServiceManager(ABC):
+    """
+    Abstract base class for service managers.
+    Provides common functionality for service registration and lifecycle
+    management.
+    """
+
+    def __init__(self):
+        self.services = []
+        self.service_instances = {}
+        self._exit_stack = AsyncExitStack()
+
+        # Initialize default services
+        self._register_default_services()
+
+    @abstractmethod
+    def _register_default_services(self):
+        """
+        Register default services for this manager. Override in
+        subclasses.
+        """
+
+    def register(self, service_class: Type, *args, name: str = None, **kwargs):
+        """
+        Register a service.
+
+        Args:
+            service_class: The class of the service to register.
+            *args: Positional arguments for service initialization.
+            name: Optional service name. Defaults to class name without
+                'Service' suffix and converted to lowercase.
+            **kwargs: Keyword arguments for service initialization.
+
+        Returns:
+            self: For method chaining
+        """
+        if name is None:
+            name = service_class.__name__.replace("Service", "").lower()
+
+        # Check if service name already exists
+        if any(service[3] == name for service in self.services):
+            raise ValueError(
+                f"Service with name '{name}' is already registered",
+            )
+
+        self.services.append((service_class, args, kwargs, name))
+        logger.debug(f"Registered service: {name} ({service_class.__name__})")
+        return self
+
+    def register_service(self, name: str, service: Service):
+        """Register an already instantiated service.
+
+        Args:
+            name: Service name
+            service: Service instance
+
+        Returns:
+            self: For method chaining
+        """
+        if name in self.service_instances:
+            raise ValueError(
+                f"Service with name '{name}' is already registered",
+            )
+
+        self.service_instances[name] = service
+        logger.debug(f"Registered service instance: {name}")
+        return self
+
+    async def __aenter__(self):
+        """Start all registered services using AsyncExitStack."""
+        try:
+            # Track services that were registered with register() to avoid
+            # duplicate processing
+            registered_names = set()
+
+            # Start services that were registered with register()
+            for service_class, args, kwargs, name in self.services:
+                logger.debug(f"Starting service: {name}")
+                instance = service_class(*args, **kwargs)
+
+                # Use AsyncExitStack to manage the context
+                await self._exit_stack.enter_async_context(instance)
+                self.service_instances[name] = instance
+                registered_names.add(name)  # Track this service as processed
+                logger.debug(f"Successfully started service: {name}")
+
+            # Start services that were registered with register_service()
+            # These services are already instantiated, just need to enter
+            # their context
+            for name, service in list(self.service_instances.items()):
+                if (
+                    name not in registered_names
+                ):  # Only process services not from register() method
+                    logger.debug(f"Starting pre-instantiated service: {name}")
+                    await self._exit_stack.enter_async_context(service)
+                    logger.debug(
+                        f"Successfully started pre-instantiated service:"
+                        f" {name}",
+                    )
+
+            return self
+
+        except Exception as e:
+            logger.error(f"Failed to start services: {e}")
+            # Ensure proper cleanup if initialization fails
+            await self._exit_stack.aclose()
+            raise
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Close all services using AsyncExitStack."""
+        logger.debug("Stopping all services")
+        await self._exit_stack.aclose()
+        self.service_instances.clear()
+        logger.debug("All services stopped")
+        return False
+
+    def __getattr__(self, name: str):
+        """
+        Enable attribute access for services, e.g., manager.env,
+        manager.session.
+        """
+        if name in self.service_instances:
+            return self.service_instances[name]
+        raise AttributeError(f"Service '{name}' not found")
+
+    def __getitem__(self, name: str):
+        """Enable dictionary-style access for services."""
+        if name in self.service_instances:
+            return self.service_instances[name]
+        raise KeyError(f"Service '{name}' not found")
+
+    def get(self, name: str, default=None):
+        """Explicitly retrieve a service instance with optional default."""
+        return self.service_instances.get(name, default)
+
+    def has_service(self, name: str) -> bool:
+        """Check if a service exists."""
+        return name in self.service_instances
+
+    def list_services(self) -> List[str]:
+        """List all registered service names."""
+        return list(self.service_instances.keys())
+
+    @property
+    def all_services(self) -> Dict[str, Any]:
+        """Retrieve all service instances."""
+        return self.service_instances.copy()
+
+    async def health_check(self) -> Dict[str, bool]:
+        """Check health of all services."""
+        health_status = {}
+        for name, service in self.service_instances.items():
+            try:
+                if hasattr(service, "health"):
+                    health_status[name] = await service.health()
+                else:
+                    health_status[
+                        name
+                    ] = True  # Assume healthy if no health method
+            except Exception as e:
+                logger.error(f"Health check failed for service {name}: {e}")
+                health_status[name] = False
+        return health_status

agentscope_runtime/engine/services/memory_service.py

@@ -0,0 +1,270 @@
+# -*- coding: utf-8 -*-
+from abc import abstractmethod
+from typing import Optional, Dict, Any
+
+
+from pydantic import Field
+
+from .base import ServiceWithLifecycleManager
+from ..schemas.agent_schemas import MessageType, Message
+
+
+class MemoryService(ServiceWithLifecycleManager):
+    """
+    Used to store and retrieve long memory from the database or in-memory.
+    The memory is organized by the user id at top level, under which there are
+    two different memory manage strategies,
+    - one is the message grouped by the session id, the session id is under
+    the user id,
+    - the other is the message grouped by the user id only
+    """
+
+    @abstractmethod
+    async def add_memory(
+        self,
+        user_id: str,
+        messages: list,
+        session_id: Optional[str] = None,
+    ) -> None:
+        """
+        Adds messages to the memory service.
+
+        Args:
+            user_id: The user id.
+            messages: The messages to add.
+            session_id: The session id, which is optional.
+        """
+
+    async def stop(self):
+        raise NotImplementedError
+
+    async def start(self):
+        raise NotImplementedError
+
+    @abstractmethod
+    async def search_memory(
+        self,
+        user_id: str,
+        messages: list,
+        filters: Optional[Dict[str, Any]] = Field(
+            description="Associated filters for the messages, "
+            "such as top_k, score etc.",
+            default=None,
+        ),
+    ) -> list:
+        """
+        Searches messages from the memory service.
+
+        Args:
+            user_id: The user id.
+            messages: The user query or the query with history messages,
+            both in the format of list of messages.  If messages is a list,
+            the search will be based on the content of the last message.
+            filters: The filters used to search memory
+        """
+
+    @abstractmethod
+    async def list_memory(
+        self,
+        user_id: str,
+        filters: Optional[Dict[str, Any]] = Field(
+            description="Associated filters for the messages, "
+            "such as top_k, score etc.",
+            default=None,
+        ),
+    ) -> list:
+        """
+        Lists the memory items for a given user with filters, such as
+        page_num, page_size, etc.
+
+        Args:
+            user_id: The user id.
+            filters: The filters for the memory items.
+        """
+
+    @abstractmethod
+    async def delete_memory(
+        self,
+        user_id: str,
+        session_id: Optional[str] = None,
+    ) -> None:
+        """
+        Deletes the memory items for a given user with certain session id,
+        or all the memory items for a given user.
+        """
+
+
+class InMemoryMemoryService(MemoryService):
+    """
+    An in-memory implementation of the memory service.
+    """
+
+    _store: Dict[str, Dict[str, list]] = {}
+    _DEFAULT_SESSION_ID = "default"
+
+    async def start(self) -> None:
+        """Starts the service."""
+        self._store = {}
+
+    async def stop(self) -> None:
+        """Stops the service."""
+        self._store = {}
+
+    async def health(self) -> bool:
+        """Checks the health of the service."""
+        return True
+
+    async def add_memory(
+        self,
+        user_id: str,
+        messages: list,
+        session_id: Optional[str] = None,
+    ) -> None:
+        """
+        Adds messages to the in-memory store.
+
+        Args:
+            user_id: The user's unique identifier.
+            messages: A list of messages to be added.
+            session_id: An optional session identifier. If not provided,
+            a default session is used.
+        """
+        if user_id not in self._store:
+            self._store[user_id] = {}
+
+        storage_key = session_id if session_id else self._DEFAULT_SESSION_ID
+
+        if storage_key not in self._store[user_id]:
+            self._store[user_id][storage_key] = []
+
+        self._store[user_id][storage_key].extend(messages)
+
+    async def search_memory(
+        self,
+        user_id: str,
+        messages: list,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> list:
+        """
+        Searches messages from the in-memory store for a specific user
+            based on keywords.
+
+        Args:
+            user_id: The user's unique identifier.
+            messages: A list of messages, where the last message's content
+                is used as the search query.
+            filters: Optional filters to apply, such as 'top_k' to limit the
+                number of returned messages.
+
+        Returns:
+            A list of matching messages from the store.
+        """
+        if user_id not in self._store:
+            return []
+
+        if (
+            not messages
+            or not isinstance(messages, list)
+            or len(messages) == 0
+        ):
+            return []
+
+        message = messages[-1]
+        query = await self.get_query_text(message)
+        if not query:
+            return []
+
+        keywords = set(query.lower().split())
+
+        all_messages = []
+        for session_messages in self._store[user_id].values():
+            all_messages.extend(session_messages)
+
+        matched_messages = []
+        for msg in all_messages:
+            candidate_content = await self.get_query_text(msg)
+            if candidate_content:
+                msg_content_lower = candidate_content.lower()
+                if any(keyword in msg_content_lower for keyword in keywords):
+                    matched_messages.append(msg)
+
+        if (
+            filters
+            and "top_k" in filters
+            and isinstance(filters["top_k"], int)
+        ):
+            return matched_messages[-filters["top_k"] :]
+
+        return matched_messages
+
+    async def get_query_text(self, message: Message) -> str:
+        """
+        Gets the query text from the messages.
+
+        Args:
+            message: A list of messages.
+
+        Returns:
+            The query text.
+        """
+        if message:
+            if message.type == MessageType.MESSAGE:
+                for content in message.content:
+                    if content.type == "text":
+                        return content.text
+        return ""
+
+    async def list_memory(
+        self,
+        user_id: str,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> list:
+        """
+        Lists messages from the in-memory store with pagination support.
+
+        Args:
+            user_id: The user's unique identifier.
+            filters: Optional filters for pagination, including 'page_num'
+                and 'page_size'.
+
+        Returns:
+            A paginated list of messages.
+        """
+        if user_id not in self._store:
+            return []
+
+        all_messages = []
+        # Sort by session id to have a consistent order for pagination
+        for session_id in sorted(self._store[user_id].keys()):
+            all_messages.extend(self._store[user_id][session_id])
+
+        page_num = filters.get("page_num", 1) if filters else 1
+        page_size = filters.get("page_size", 10) if filters else 10
+
+        start_index = (page_num - 1) * page_size
+        end_index = start_index + page_size
+
+        return all_messages[start_index:end_index]
+
+    async def delete_memory(
+        self,
+        user_id: str,
+        session_id: Optional[str] = None,
+    ) -> None:
+        """
+        Deletes messages from the in-memory store.
+
+        Args:
+            user_id: The user's unique identifier.
+            session_id: If provided, only deletes the messages for that
+                session. Otherwise, deletes all messages for the user.
+        """
+        if user_id not in self._store:
+            return
+
+        if session_id:
+            if session_id in self._store[user_id]:
+                del self._store[user_id][session_id]
+        else:
+            if user_id in self._store:
+                del self._store[user_id]