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

agentscope_runtime/engine/services/session_history/session_history_service.py

@@ -1,267 +0,0 @@
-# -*- coding: utf-8 -*-
-import copy
-import uuid
-from abc import abstractmethod
-from typing import List, Dict, Optional, Union, Any
-
-from ..base import ServiceWithLifecycleManager
-from ...schemas.session import Session
-from ...schemas.agent_schemas import Message
-
-
-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
-
-    @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:
-        _store: A dictionary holding all session objects, keyed by user ID
-            and then by session ID.
-    """
-
-    def __init__(self) -> None:
-        """Initializes the InMemorySessionHistoryService."""
-        self._store: Optional[Dict[str, Dict[str, Session]]] = 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 data."""
-        if self._store is not None:
-            self._store.clear()
-        self._store = None
-        self._health = False
-
-    async def health(self) -> bool:
-        """Service health check: always True."""
-        return self._health
-
-    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.
-        """
-        if self._store is None:
-            raise RuntimeError("Service not started")
-
-        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._store.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.
-        """
-        if self._store is None:
-            raise RuntimeError("Service not started")
-
-        session = self._store.get(user_id, {}).get(session_id)
-        if not session:
-            session = Session(id=session_id, user_id=user_id)
-            self._store.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 self._store is None:
-            raise RuntimeError("Service not started")
-
-        if user_id in self._store and session_id in self._store[user_id]:
-            del self._store[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.
-        """
-        if self._store is None:
-            raise RuntimeError("Service not started")
-
-        user_sessions = self._store.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.
-        """
-        if self._store is None:
-            raise RuntimeError("Service not started")
-
-        # Normalize to list
-        if not isinstance(message, list):
-            message = [message]
-
-        norm_message = []
-        for msg in message:
-            if msg is not None:
-                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._store.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/services/session_history/session_history_service_factory.py

@@ -1,73 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from typing import Callable, Dict
-
-from ..service_factory import ServiceFactory
-from .session_history_service import (
-    SessionHistoryService,
-    InMemorySessionHistoryService,
-)
-from .redis_session_history_service import RedisSessionHistoryService
-
-try:
-    from .tablestore_session_history_service import (
-        TablestoreSessionHistoryService,
-    )
-
-    TABLESTORE_AVAILABLE = True
-except ImportError:
-    TABLESTORE_AVAILABLE = False
-
-
-class SessionHistoryServiceFactory(ServiceFactory[SessionHistoryService]):
-    """
-    Factory for SessionHistoryService, supporting both environment variables
-    and keyword arguments.
-
-    Usage examples:
-        1. Start with only environment variables:
-            export SESSION_HISTORY_BACKEND=redis
-            export SESSION_HISTORY_REDIS_REDIS_URL="redis://localhost:6379/5"
-            service = await SessionHistoryServiceFactory.create()
-
-        2. Override environment variables with arguments:
-            export SESSION_HISTORY_BACKEND=redis
-            export SESSION_HISTORY_REDIS_REDIS_URL="redis://localhost:6379/5"
-            service = await SessionHistoryServiceFactory.create(
-                redis_url="redis://otherhost:6379/1"
-            )
-
-        3. Register a custom backend:
-            from my_backend import PostgresSessionHistoryService
-            SessionHistoryServiceFactory.register_backend(
-                "postgres",
-                PostgresSessionHistoryService,
-            )
-            export SESSION_HISTORY_BACKEND=postgres
-            export SESSION_HISTORY_POSTGRES_DSN="postgresql://user:pass@localhost/db"  # noqa
-            export SESSION_HISTORY_POSTGRES_POOL_SIZE="20"
-            service = await SessionHistoryServiceFactory.create()
-    """
-
-    _registry: Dict[str, Callable[..., SessionHistoryService]] = {}
-    _env_prefix = "SESSION_HISTORY_"
-    _default_backend = "in_memory"
-
-
-# === Default built-in backend registration ===
-
-SessionHistoryServiceFactory.register_backend(
-    "in_memory",
-    InMemorySessionHistoryService,
-)
-
-SessionHistoryServiceFactory.register_backend(
-    "redis",
-    RedisSessionHistoryService,
-)
-
-if TABLESTORE_AVAILABLE:
-    SessionHistoryServiceFactory.register_backend(
-        "tablestore",
-        TablestoreSessionHistoryService,
-    )

agentscope_runtime/engine/services/session_history/tablestore_session_history_service.py

@@ -1,288 +0,0 @@
-# -*- coding: utf-8 -*-
-# pylint: disable=redefined-outer-name
-import asyncio
-import uuid
-from typing import Any, Dict, List, Optional, Union
-
-import tablestore
-from tablestore import AsyncOTSClient as AsyncTablestoreClient
-from tablestore_for_agent_memory.base.base_memory_store import (
-    Session as TablestoreSession,
-)
-from tablestore_for_agent_memory.base.common import MetaType, Order
-from tablestore_for_agent_memory.memory.async_memory_store import (
-    AsyncMemoryStore,
-)
-
-from .session_history_service import SessionHistoryService
-from ...schemas.agent_schemas import Message
-from ...schemas.session import Session
-from ..utils.tablestore_service_utils import (
-    convert_message_to_tablestore_message,
-    convert_tablestore_session_to_session,
-    tablestore_log,
-)
-
-
-class TablestoreSessionHistoryService(SessionHistoryService):
-    """An aliyun tablestore implementation of the SessionHistoryService
-    based on tablestore_for_agent_memory
-    (https://github.com/aliyun/
-    alibabacloud-tablestore-for-agent-memory/blob/main/python/docs/memory_store_tutorial.ipynb).
-    """
-
-    _SESSION_SECONDARY_INDEX_NAME = (
-        "agentscope_runtime_session_secondary_index"
-    )
-    _SESSION_SEARCH_INDEX_NAME = "agentscope_runtime_session_search_index"
-    _MESSAGE_SECONDARY_INDEX_NAME = (
-        "agentscope_runtime_message_secondary_index"
-    )
-    _MESSAGE_SEARCH_INDEX_NAME = "agentscope_runtime_message_search_index"
-
-    def __init__(
-        self,
-        tablestore_client: AsyncTablestoreClient,
-        session_table_name: Optional[str] = "agentscope_runtime_session",
-        message_table_name: Optional[str] = "agentscope_runtime_message",
-        session_secondary_index_meta: Optional[Dict[str, MetaType]] = None,
-        session_search_index_schema: Optional[
-            List[tablestore.FieldSchema]
-        ] = None,
-        message_search_index_schema: Optional[
-            List[tablestore.FieldSchema]
-        ] = None,
-        **kwargs: Any,
-    ) -> None:
-        """Initializes the TablestoreSessionHistoryService."""
-        self._tablestore_client = tablestore_client
-        self._session_table_name = session_table_name
-        self._message_table_name = message_table_name
-        self._session_secondary_index_meta = session_secondary_index_meta
-        self._session_search_index_schema = session_search_index_schema
-        self._message_search_index_schema = message_search_index_schema
-        self._memory_store: Optional[AsyncMemoryStore] = None
-        self._memory_store_init_parameter_kwargs = kwargs
-
-    async def _init_memory_store(self) -> None:
-        self._memory_store = AsyncMemoryStore(
-            tablestore_client=self._tablestore_client,
-            session_table_name=self._session_table_name,
-            message_table_name=self._message_table_name,
-            session_secondary_index_name=self._SESSION_SECONDARY_INDEX_NAME,
-            session_search_index_name=self._SESSION_SEARCH_INDEX_NAME,
-            message_secondary_index_name=self._MESSAGE_SECONDARY_INDEX_NAME,
-            message_search_index_name=self._MESSAGE_SEARCH_INDEX_NAME,
-            session_secondary_index_meta=self._session_secondary_index_meta,
-            session_search_index_schema=self._session_search_index_schema,
-            message_search_index_schema=self._message_search_index_schema,
-            **self._memory_store_init_parameter_kwargs,
-        )
-
-        await self._memory_store.init_table()
-        await self._memory_store.init_search_index()
-
-    async def start(self) -> None:
-        """Start the tablestore service"""
-        if self._memory_store:
-            return
-        await self._init_memory_store()
-
-    async def stop(self) -> None:
-        """Close the tablestore service"""
-        if self._memory_store is None:
-            return
-        memory_store = self._memory_store
-        self._memory_store = None
-        await memory_store.close()
-
-    async def health(self) -> bool:
-        """Checks the health of the service."""
-        if self._memory_store is None:
-            tablestore_log(
-                "Tablestore session history service is not started.",
-            )
-            return False
-
-        try:
-            async for _ in await self._memory_store.list_all_sessions():
-                return True
-            return True
-        except Exception as e:
-            tablestore_log(
-                f"Tablestore session history service "
-                f"cannot access Tablestore, error: {str(e)}.",
-            )
-            return False
-
-    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 newly created Session object.
-        """
-        session_id = (
-            session_id.strip()
-            if session_id and session_id.strip()
-            else str(uuid.uuid4())
-        )
-        tablestore_session = TablestoreSession(
-            session_id=session_id,
-            user_id=user_id,
-        )
-
-        await self._memory_store.put_session(tablestore_session)
-        return convert_tablestore_session_to_session(tablestore_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 Session object if found, otherwise None.
-        """
-
-        tablestore_session = await self._memory_store.get_session(
-            user_id=user_id,
-            session_id=session_id,
-        )
-
-        if not tablestore_session:
-            tablestore_session = TablestoreSession(
-                session_id=session_id,
-                user_id=user_id,
-            )
-            await self._memory_store.put_session(tablestore_session)
-            tablestore_messages = None
-        else:
-            messages_iterator = await self._memory_store.list_messages(
-                session_id=session_id,
-                order=Order.ASC,
-                # Sort by timestamp,
-                # keeping the most recent information at the end of the list.
-            )
-            tablestore_messages = [
-                message async for message in messages_iterator
-            ]
-
-        return convert_tablestore_session_to_session(
-            tablestore_session,
-            tablestore_messages,
-        )
-
-    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.
-        """
-        await self._memory_store.delete_session_and_messages(
-            user_id=user_id,
-            session_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.
-        """
-        tablestore_sessions = await self._memory_store.list_sessions(user_id)
-        return [
-            convert_tablestore_session_to_session(tablestore_session)
-            async for tablestore_session in tablestore_sessions
-        ]
-
-    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 msg is None:
-                continue
-
-            if not isinstance(msg, Message):
-                msg = Message.model_validate(msg)
-            norm_message.append(msg)
-        session.messages.extend(norm_message)
-
-        tablestore_session = await self._memory_store.get_session(
-            session_id=session.id,
-            user_id=session.user_id,
-        )
-        if tablestore_session:
-            put_tasks = [
-                self._memory_store.put_message(
-                    convert_message_to_tablestore_message(message, session),
-                )
-                for message in norm_message
-            ]
-            await asyncio.gather(*put_tasks)
-
-        else:
-            tablestore_log(
-                f"Warning: Session {session.id} not found "
-                f"in tablestore storage for "
-                f"append_message.",
-            )
-
-    async def delete_user_sessions(self, user_id: str) -> None:
-        """
-        Deletes all session history data for a specific user.
-
-        Args:
-            user_id (str): The ID of the user whose session history data should
-             be deleted
-        """
-        delete_tasks = [
-            self.delete_session(user_id, session.id)
-            for session in (await self.list_sessions(user_id=user_id))
-        ]
-        await asyncio.gather(*delete_tasks)