agentscope-runtime 1.0.5.post1__py3-none-any.whl → 1.1.0b3__py3-none-any.whl

agentscope_runtime/adapters/agentscope/memory/_memory_adapter.py

@@ -1,152 +0,0 @@
-# -*- coding: utf-8 -*-
-# pylint:disable=protected-access
-"""AgentScope Memory implementation based on SessionHistoryService."""
-import functools
-
-from typing import Union
-
-from agentscope.memory import MemoryBase
-from agentscope.message import Msg
-
-from ..message import agentscope_msg_to_message, message_to_agentscope_msg
-from ....engine.services.session_history import SessionHistoryService
-
-
-def ensure_session(func):
-    """
-    Async decorator that ensures the AgentScope session exists before
-    method execution.
-    """
-
-    @functools.wraps(func)
-    async def wrapper(self, *args, **kwargs):
-        await self._check_session()
-        return await func(self, *args, **kwargs)
-
-    return wrapper
-
-
-class AgentScopeSessionHistoryMemory(MemoryBase):
-    """
-    AgentScope Memory subclass based on MemoryBase.
-
-    This class stores messages in an underlying SessionHistoryService instance.
-
-    Args:
-        service (SessionHistoryService): The backend session history service.
-        user_id (str): The user ID linked to this memory.
-        session_id (str): The session ID linked to this memory.
-    """
-
-    def __init__(
-        self,
-        service: SessionHistoryService,
-        user_id: str,
-        session_id: str,
-    ):
-        super().__init__()
-        self._service = service
-        self.user_id = user_id
-        self.session_id = session_id
-        self._session = None
-
-    async def _check_session(self) -> None:
-        """
-        Check if the session exists in the backend.
-        """
-        # Always check for session to stay in sync with backend
-        self._session = await self._service.get_session(
-            self.user_id,
-            self.session_id,
-        )
-        if self._session is None:
-            self._session = await self._service.create_session(
-                self.user_id,
-                self.session_id,
-            )
-
-    def state_dict(self):
-        """
-        Get current memory state as a dictionary.
-        Always fetch from backend to ensure consistency.
-        """
-
-    def load_state_dict(
-        self,
-        state_dict: dict,
-        strict: bool = True,
-    ) -> None:
-        """
-        Load memory state from a dictionary into backend storage.
-        """
-
-    @ensure_session
-    async def size(self) -> int:
-        """The size of the memory."""
-        current_message = self._session.messages
-        agentscope_msg = message_to_agentscope_msg(current_message)
-        return len(agentscope_msg)
-
-    @ensure_session
-    async def add(
-        self,
-        memories: Union[list[Msg], Msg, None],
-        allow_duplicates: bool = False,  # pylint: disable=unused-argument
-    ) -> None:
-        """Add messages to backend service."""
-        if memories is None:
-            return
-        if isinstance(memories, Msg):
-            memories = [memories]
-        if not isinstance(memories, list):
-            raise TypeError(f"Expected Msg or list[Msg], got {type(memories)}")
-
-        # Convert Msg -> backend Message
-        backend_messages = agentscope_msg_to_message(memories)
-
-        if self._session:
-            await self._service.append_message(self._session, backend_messages)
-
-    @ensure_session
-    async def delete(self, index: Union[list[int], int]) -> None:
-        """
-        Delete messages by index
-        """
-        # TODO: add method to delete messages instead of replacement
-        if isinstance(index, int):
-            index = [index]
-
-        current_message = self._session.messages
-        agentscope_msg = message_to_agentscope_msg(current_message)
-
-        invalid_index = [_ for _ in index if _ < 0 or _ >= len(agentscope_msg)]
-
-        if invalid_index:
-            raise IndexError(
-                f"The index {invalid_index} does not exist.",
-            )
-
-        agentscope_msg = [
-            _ for idx, _ in enumerate(agentscope_msg) if idx not in index
-        ]
-
-        await self.clear()
-        await self.add(agentscope_msg)
-
-    @ensure_session
-    async def clear(self) -> None:
-        """Clear backend session memory."""
-        await self._service.delete_session(
-            user_id=self.user_id,
-            session_id=self.session_id,
-        )
-
-    @ensure_session
-    async def get_memory(self) -> list[Msg]:
-        """
-        Retrieve memory content.
-        For sync purposes, we reload from backend before returning.
-        """
-        current_message = self._session.messages
-        agentscope_msg = message_to_agentscope_msg(current_message)
-        return agentscope_msg

agentscope_runtime/engine/services/agent_state/__init__.py

@@ -1,25 +0,0 @@
-# -*- 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.session",
-)
-
-if TYPE_CHECKING:
-    from .state_service import StateService, InMemoryStateService
-    from .redis_state_service import RedisStateService
-    from .state_service_factory import StateServiceFactory
-
-install_lazy_loader(
-    globals(),
-    {
-        "StateService": ".state_service",
-        "InMemoryStateService": ".state_service",
-        "RedisStateService": ".redis_state_service",
-        "StateServiceFactory": ".state_service_factory",
-    },
-)

agentscope_runtime/engine/services/agent_state/redis_state_service.py

@@ -1,166 +0,0 @@
-# -*- coding: utf-8 -*-
-import json
-from typing import Optional, Dict, Any
-
-import redis.asyncio as aioredis
-
-from .state_service import StateService
-
-
-class RedisStateService(StateService):
-    """
-    Redis-based implementation of StateService.
-
-    Stores agent states in Redis using a hash per (user_id, session_id),
-    with round_id as the hash field and serialized state as the value.
-    """
-
-    _DEFAULT_SESSION_ID = "default"
-
-    def __init__(
-        self,
-        redis_url: str = "redis://localhost:6379/0",
-        redis_client: Optional[aioredis.Redis] = None,
-        socket_timeout: Optional[float] = 5.0,
-        socket_connect_timeout: Optional[float] = 5.0,
-        max_connections: Optional[int] = None,
-        retry_on_timeout: bool = True,
-        ttl_seconds: Optional[int] = 3600,  # 1 hour in seconds
-        health_check_interval: Optional[float] = 30.0,
-        socket_keepalive: bool = True,
-    ):
-        """
-        Initialize RedisStateService.
-
-        Args:
-            redis_url: Redis connection URL
-            redis_client: Optional pre-configured Redis client
-            socket_timeout: Socket timeout in seconds (default: 5.0)
-            socket_connect_timeout: Socket connect timeout in seconds
-            (default: 5.0)
-            max_connections: Maximum number of connections in the pool
-            (default: None)
-            retry_on_timeout: Whether to retry on timeout (default: True)
-            ttl_seconds: Time-to-live in seconds for state data. If None,
-            data never expires (default: 3600, i.e., 1 hour)
-            health_check_interval: Interval in seconds for health checks on
-            idle connections (default: 30.0).
-                Connections idle longer than this will be checked before reuse.
-                Set to 0 to disable.
-            socket_keepalive: Enable TCP keepalive to prevent
-            silent disconnections (default: True)
-        """
-        self._redis_url = redis_url
-        self._redis = redis_client
-        self._socket_timeout = socket_timeout
-        self._socket_connect_timeout = socket_connect_timeout
-        self._max_connections = max_connections
-        self._retry_on_timeout = retry_on_timeout
-        self._ttl_seconds = ttl_seconds
-        self._health_check_interval = health_check_interval
-        self._socket_keepalive = socket_keepalive
-
-    async def start(self) -> None:
-        """Starts the Redis connection with proper timeout and connection
-        pool settings."""
-        if self._redis is None:
-            self._redis = aioredis.from_url(
-                self._redis_url,
-                decode_responses=True,
-                socket_timeout=self._socket_timeout,
-                socket_connect_timeout=self._socket_connect_timeout,
-                max_connections=self._max_connections,
-                retry_on_timeout=self._retry_on_timeout,
-                health_check_interval=self._health_check_interval,
-                socket_keepalive=self._socket_keepalive,
-            )
-
-    async def stop(self) -> None:
-        """Closes the Redis connection."""
-        if self._redis:
-            await self._redis.aclose()
-            self._redis = None
-
-    async def health(self) -> bool:
-        """Checks the health of the service."""
-        if not self._redis:
-            return False
-        try:
-            pong = await self._redis.ping()
-            return pong is True or pong == "PONG"
-        except Exception:
-            return False
-
-    def _session_key(self, user_id: str, session_id: str) -> str:
-        """Generate the Redis key for a user's session."""
-        return f"user_state:{user_id}:{session_id}"
-
-    async def save_state(
-        self,
-        user_id: str,
-        state: Dict[str, Any],
-        session_id: Optional[str] = None,
-        round_id: Optional[int] = None,
-    ) -> int:
-        if not self._redis:
-            raise RuntimeError("Redis connection is not available")
-
-        sid = session_id or self._DEFAULT_SESSION_ID
-        key = self._session_key(user_id, sid)
-
-        existing_fields = await self._redis.hkeys(key)
-        existing_rounds = sorted(
-            int(f) for f in existing_fields if f.isdigit()
-        )
-
-        if round_id is None:
-            if existing_rounds:
-                round_id = max(existing_rounds) + 1
-            else:
-                round_id = 1
-
-        await self._redis.hset(key, round_id, json.dumps(state))
-
-        # Set TTL for the state key if configured
-        if self._ttl_seconds is not None:
-            await self._redis.expire(key, self._ttl_seconds)
-
-        return round_id
-
-    async def export_state(
-        self,
-        user_id: str,
-        session_id: Optional[str] = None,
-        round_id: Optional[int] = None,
-    ) -> Optional[Dict[str, Any]]:
-        if not self._redis:
-            raise RuntimeError("Redis connection is not available")
-
-        sid = session_id or self._DEFAULT_SESSION_ID
-        key = self._session_key(user_id, sid)
-
-        existing_fields = await self._redis.hkeys(key)
-        if not existing_fields:
-            return None
-
-        if round_id is None:
-            numeric_fields = [int(f) for f in existing_fields if f.isdigit()]
-            if not numeric_fields:
-                return None
-            latest_round_id = max(numeric_fields)
-            state_json = await self._redis.hget(key, latest_round_id)
-        else:
-            state_json = await self._redis.hget(key, round_id)
-
-        if state_json is None:
-            return None
-
-        # Refresh TTL when accessing the state
-        if self._ttl_seconds is not None:
-            await self._redis.expire(key, self._ttl_seconds)
-
-        try:
-            return json.loads(state_json)
-        except json.JSONDecodeError:
-            # Return None for corrupted state data instead of raising exception
-            return None

agentscope_runtime/engine/services/agent_state/state_service.py

@@ -1,179 +0,0 @@
-# -*- coding: utf-8 -*-
-import copy
-
-from abc import abstractmethod
-from typing import Dict, Any, Optional
-
-from ..base import ServiceWithLifecycleManager
-
-
-class StateService(ServiceWithLifecycleManager):
-    """
-    Abstract base class for agent state management services.
-
-    Stores and manages agent states organized by user_id, session_id,
-    and round_id. Supports saving, retrieving, listing, and deleting states.
-    """
-
-    async def start(self) -> None:
-        pass
-
-    async def stop(self) -> None:
-        pass
-
-    @abstractmethod
-    async def save_state(
-        self,
-        user_id: str,
-        state: Dict[str, Any],
-        session_id: Optional[str] = None,
-        round_id: Optional[int] = None,
-    ) -> int:
-        """
-        Save serialized state data for a specific user/session.
-
-        If round_id is provided, store the state in that round.
-        If round_id is None, append as a new round with automatically
-        assigned round_id.
-
-        Args:
-            user_id: The unique ID of the user.
-            state: A dictionary representing serialized agent state.
-            session_id: Optional session/conversation ID. Defaults to
-                "default".
-            round_id: Optional conversation round number.
-
-        Returns:
-            The round_id in which the state was saved.
-        """
-
-    @abstractmethod
-    async def export_state(
-        self,
-        user_id: str,
-        session_id: Optional[str] = None,
-        round_id: Optional[int] = None,
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Retrieve serialized state data for a user/session.
-
-        If round_id is provided, return that round's state.
-        If round_id is None, return the latest round's state.
-
-        Args:
-            user_id: The unique ID of the user.
-            session_id: Optional session/conversation ID.
-            round_id: Optional round number.
-
-        Returns:
-            A dictionary representing the agent state, or None if not found.
-        """
-
-
-class InMemoryStateService(StateService):
-    """
-    In-memory implementation of StateService using dictionaries
-    for sparse round storage.
-
-    - Multiple users, sessions, and non-contiguous round IDs are supported.
-    - If round_id is None when saving, a new round is appended automatically.
-    - If round_id is None when exporting, the latest round is returned.
-    """
-
-    _DEFAULT_SESSION_ID = "default"
-
-    def __init__(self) -> None:
-        # Structure:
-        # { user_id: { session_id: { round_id: state_dict } } }
-        self._store: Optional[
-            Dict[str, Dict[str, Dict[int, Dict[str, Any]]]]
-        ] = None
-        self._health = False
-
-    async def start(self) -> None:
-        """Initialize the in-memory store."""
-        if self._store is None:
-            self._store = {}
-        self._health = True
-
-    async def stop(self) -> None:
-        """Clear all in-memory state data."""
-        if self._store is not None:
-            self._store.clear()
-        self._store = None
-        self._health = False
-
-    async def health(self) -> bool:
-        """Service health check."""
-        return self._health
-
-    async def save_state(
-        self,
-        user_id: str,
-        state: Dict[str, Any],
-        session_id: Optional[str] = None,
-        round_id: Optional[int] = None,
-    ) -> int:
-        """
-        Save serialized state in sparse dict storage.
-
-        If round_id is None, a new round_id will be assigned
-        as (max existing round_id + 1) or 1 if none exist.
-        Otherwise, the given round_id will be overwritten.
-
-        Returns:
-            The round_id where the state was saved.
-        """
-        if self._store is None:
-            raise RuntimeError("Service not started")
-
-        sid = session_id or self._DEFAULT_SESSION_ID
-
-        self._store.setdefault(user_id, {})
-        self._store[user_id].setdefault(sid, {})
-
-        rounds_dict = self._store[user_id][sid]
-
-        # Auto-generate round_id if not provided
-        if round_id is None:
-            if rounds_dict:
-                round_id = max(rounds_dict.keys()) + 1
-            else:
-                round_id = 1
-
-        # Store a deep copy so caller modifications don't affect saved state
-        rounds_dict[round_id] = copy.deepcopy(state)
-
-        return round_id
-
-    async def export_state(
-        self,
-        user_id: str,
-        session_id: Optional[str] = None,
-        round_id: Optional[int] = None,
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Retrieve state data for given user/session/round.
-
-        If round_id is None: return the latest round.
-        If round_id is provided: return that round's state.
-
-        Returns:
-            Dictionary representing the agent state, or None if not found.
-        """
-        if self._store is None:
-            raise RuntimeError("Service not started")
-
-        sid = session_id or self._DEFAULT_SESSION_ID
-        sessions = self._store.get(user_id, {})
-        rounds_dict = sessions.get(sid, {})
-
-        if not rounds_dict:
-            return None
-
-        if round_id is None:
-            # Get the latest round_id
-            latest_round_id = max(rounds_dict.keys())
-            return rounds_dict[latest_round_id]
-
-        return rounds_dict.get(round_id)

agentscope_runtime/engine/services/agent_state/state_service_factory.py

@@ -1,52 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from typing import Callable, Dict
-
-from ..service_factory import ServiceFactory
-from .state_service import StateService, InMemoryStateService
-from .redis_state_service import RedisStateService
-
-
-class StateServiceFactory(ServiceFactory[StateService]):
-    """
-    Factory for StateService, supports both environment variables and kwargs
-    parameters.
-
-    Usage examples:
-        1. Start with environment variables only:
-            export STATE_BACKEND=redis
-            export STATE_REDIS_REDIS_URL="redis://localhost:6379/5"
-            service = await StateServiceFactory.create()
-
-        2. Override environment variables with arguments:
-            export STATE_BACKEND=redis
-            export STATE_REDIS_REDIS_URL="redis://localhost:6379/5"
-            service = await StateServiceFactory.create(
-                redis_url="redis://otherhost:6379/1"
-            )
-
-        3. User-defined backend:
-            from my_backend import PostgresStateService
-            StateServiceFactory.register_backend(
-                "postgres",
-                PostgresStateService,
-            )
-            export STATE_BACKEND=postgres
-            export STATE_POSTGRES_DSN="postgresql://user:pass@localhost/db"
-            service = await StateServiceFactory.create()
-    """
-
-    _registry: Dict[str, Callable[..., StateService]] = {}
-    _env_prefix = "STATE_"
-    _default_backend = "in_memory"
-
-
-StateServiceFactory.register_backend(
-    "in_memory",
-    InMemoryStateService,
-)
-
-StateServiceFactory.register_backend(
-    "redis",
-    RedisStateService,
-)

agentscope_runtime/engine/services/memory/__init__.py

@@ -1,33 +0,0 @@
-# -*- 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 .memory_service import MemoryService, InMemoryMemoryService
-    from .redis_memory_service import RedisMemoryService
-    from .reme_task_memory_service import ReMeTaskMemoryService
-    from .reme_personal_memory_service import ReMePersonalMemoryService
-    from .mem0_memory_service import Mem0MemoryService
-    from .tablestore_memory_service import TablestoreMemoryService
-    from .memory_service_factory import MemoryServiceFactory
-
-install_lazy_loader(
-    globals(),
-    {
-        "MemoryService": ".memory_service",
-        "InMemoryMemoryService": ".memory_service",
-        "RedisMemoryService": ".redis_memory_service",
-        "ReMeTaskMemoryService": ".reme_task_memory_service",
-        "ReMePersonalMemoryService": ".reme_personal_memory_service",
-        "Mem0MemoryService": ".mem0_memory_service",
-        "TablestoreMemoryService": ".tablestore_memory_service",
-        "MemoryServiceFactory": ".memory_service_factory",
-    },
-)