agentscope-runtime 0.2.0b1__py3-none-any.whl → 1.0.0__py3-none-any.whl

agentscope_runtime/engine/deployers/utils/service_utils/service_config.py

@@ -1,75 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Service configuration models for dynamic service loading."""
-
-from enum import Enum
-from typing import Dict, Any, Optional
-
-from pydantic import BaseModel
-
-
-class ServiceType(str, Enum):
-    """Types of services that can be configured."""
-
-    MEMORY = "memory"
-    SESSION_HISTORY = "session_history"
-    SANDBOX = "sandbox"
-    RAG = "rag"
-
-
-class ServiceProvider(str, Enum):
-    """Service implementation providers."""
-
-    IN_MEMORY = "in_memory"
-    REDIS = "redis"
-    # Extensible for other providers
-
-
-class ServiceConfig(BaseModel):
-    """Configuration for a single service."""
-
-    provider: ServiceProvider
-    config: Optional[Dict[str, Any]] = {}
-
-
-class ServicesConfig(BaseModel):
-    """Configuration for all services."""
-
-    memory: ServiceConfig = ServiceConfig(provider=ServiceProvider.IN_MEMORY)
-    session_history: ServiceConfig = ServiceConfig(
-        provider=ServiceProvider.IN_MEMORY,
-    )
-    sandbox: Optional[ServiceConfig] = None
-    rag: Optional[ServiceConfig] = None
-
-
-# Default configuration
-DEFAULT_SERVICES_CONFIG = ServicesConfig()
-
-
-def create_redis_services_config(
-    host: str = "localhost",
-    port: int = 6379,
-    memory_db: int = 0,
-    session_db: int = 1,
-) -> ServicesConfig:
-    """Create a ServicesConfig with Redis providers.
-
-    Args:
-        host: Redis host
-        port: Redis port
-        memory_db: Redis database for memory service
-        session_db: Redis database for session history service
-
-    Returns:
-        ServicesConfig: Configuration with Redis services
-    """
-    return ServicesConfig(
-        memory=ServiceConfig(
-            provider=ServiceProvider.REDIS,
-            config={"host": host, "port": port, "db": memory_db},
-        ),
-        session_history=ServiceConfig(
-            provider=ServiceProvider.REDIS,
-            config={"host": host, "port": port, "db": session_db},
-        ),
-    )

agentscope_runtime/engine/deployers/utils/service_utils/service_factory.py

@@ -1,220 +0,0 @@
-# -*- coding: utf-8 -*-
-# pylint:disable=line-too-long
-
-from typing import Dict, Type, Any
-from .service_config import (
-    ServiceType,
-    ServiceProvider,
-    ServiceConfig,
-    ServicesConfig,
-)
-
-
-class ServiceFactory:
-    """Factory for creating service instances based on configuration."""
-
-    # Service registry mapping service types and providers to
-    # implementation classes
-    _service_registry: Dict[str, Dict[str, Type]] = {}
-
-    @classmethod
-    def _populate_registry(cls):
-        """Populate the service registry with available implementations."""
-        if cls._service_registry:
-            return  # Already populated
-
-        try:
-            # Import service implementations
-            from agentscope_runtime.engine.services.memory_service import (
-                InMemoryMemoryService,
-            )
-            from agentscope_runtime.engine.services.session_history_service import (  # noqa E501
-                InMemorySessionHistoryService,
-            )
-
-            # Register memory services
-            cls._service_registry[ServiceType.MEMORY] = {
-                ServiceProvider.IN_MEMORY: InMemoryMemoryService,
-            }
-
-            # Register session history services
-            cls._service_registry[ServiceType.SESSION_HISTORY] = {
-                ServiceProvider.IN_MEMORY: InMemorySessionHistoryService,
-            }
-
-            # Try to register Redis services if available
-
-            from agentscope_runtime.engine.services.redis_memory_service import (  # noqa E501
-                RedisMemoryService,
-            )
-            from agentscope_runtime.engine.services.redis_session_history_service import (  # noqa E501
-                RedisSessionHistoryService,
-            )
-
-            cls._service_registry[ServiceType.MEMORY][
-                ServiceProvider.REDIS
-            ] = RedisMemoryService
-            cls._service_registry[ServiceType.SESSION_HISTORY][
-                ServiceProvider.REDIS
-            ] = RedisSessionHistoryService
-
-            # Try to register other services if available
-            from agentscope_runtime.engine.services.sandbox_service import (
-                SandboxService,
-            )
-
-            # Assuming default implementation
-            cls._service_registry[ServiceType.SANDBOX] = {
-                ServiceProvider.IN_MEMORY: SandboxService,
-            }
-
-            from agentscope_runtime.engine.services.rag_service import (
-                RAGService,
-            )
-
-            # Assuming default implementation
-            cls._service_registry[ServiceType.RAG] = {
-                ServiceProvider.IN_MEMORY: RAGService,
-            }
-
-        except ImportError as e:
-            raise RuntimeError(
-                f"Failed to import required service classes: {e}",
-            ) from e
-
-    @classmethod
-    def create_service(
-        cls,
-        service_type: ServiceType,
-        config: ServiceConfig,
-    ) -> Any:
-        """Create a service instance based on type and configuration.
-
-        Args:
-            service_type: Type of service to create
-            config: Configuration for the service
-
-        Returns:
-            Service instance
-
-        Raises:
-            ValueError: If service type or provider is unknown
-            RuntimeError: If service creation fails
-        """
-        cls._populate_registry()
-
-        if service_type not in cls._service_registry:
-            raise ValueError(f"Unknown service type: {service_type}")
-
-        providers = cls._service_registry[service_type]
-        if config.provider not in providers:
-            available_providers = list(providers.keys())
-            raise ValueError(
-                f"Unknown provider '{config.provider}' for service '"
-                f"{service_type}'. Available providers: {available_providers}",
-            )
-
-        service_class = providers[config.provider]
-
-        try:
-            # Create service instance with configuration parameters
-            return service_class(**config.config)
-        except Exception as e:
-            raise RuntimeError(
-                f"Failed to create {service_type} service with provider "
-                f"'{config.provider}': {e}",
-            ) from e
-
-    @classmethod
-    def register_service(
-        cls,
-        service_type: ServiceType,
-        provider: ServiceProvider,
-        service_class: Type,
-    ):
-        """Register a new service implementation.
-
-        Args:
-            service_type: Type of service
-            provider: Service provider
-            service_class: Implementation class
-        """
-        cls._populate_registry()
-
-        if service_type not in cls._service_registry:
-            cls._service_registry[service_type] = {}
-
-        cls._service_registry[service_type][provider] = service_class
-
-    @classmethod
-    def create_services_from_config(
-        cls,
-        config: ServicesConfig,
-    ) -> Dict[str, Any]:
-        """Create all services from a services configuration.
-
-        Args:
-            config: Services configuration
-
-        Returns:
-            Dict mapping service names to service instances
-
-        Raises:
-            RuntimeError: If any required service creation fails
-        """
-        services = {}
-
-        # Create required services
-        try:
-            services["memory"] = cls.create_service(
-                ServiceType.MEMORY,
-                config.memory,
-            )
-            services["session_history"] = cls.create_service(
-                ServiceType.SESSION_HISTORY,
-                config.session_history,
-            )
-        except Exception as e:
-            raise RuntimeError(
-                f"Failed to create required services: {e}",
-            ) from e
-
-        # Create optional services
-        if config.sandbox:
-            try:
-                services["sandbox"] = cls.create_service(
-                    ServiceType.SANDBOX,
-                    config.sandbox,
-                )
-            except Exception as e:
-                # Log warning but don't fail
-                print(f"Warning: Failed to create sandbox service: {e}")
-
-        if config.rag:
-            try:
-                services["rag"] = cls.create_service(
-                    ServiceType.RAG,
-                    config.rag,
-                )
-            except Exception as e:
-                # Log warning but don't fail
-                print(f"Warning: Failed to create RAG service: {e}")
-
-        return services
-
-    @classmethod
-    def get_available_providers(cls, service_type: ServiceType) -> list:
-        """Get list of available providers for a service type.
-
-        Args:
-            service_type: Type of service
-
-        Returns:
-            List of available provider names
-        """
-        cls._populate_registry()
-
-        if service_type not in cls._service_registry:
-            return []
-
-        return list(cls._service_registry[service_type].keys())

agentscope_runtime/engine/helpers/helper.py

@@ -1,179 +0,0 @@
-# -*- coding: utf-8 -*-
-import logging
-
-from agentscope_runtime.engine import Runner
-from agentscope_runtime.engine.schemas.agent_schemas import (
-    AgentRequest,
-    MessageType,
-    RunStatus,
-)
-from agentscope_runtime.engine.services.context_manager import (
-    create_context_manager,
-)
-from agentscope_runtime.engine.services.environment_manager import (
-    create_environment_manager,
-)
-
-logger = logging.getLogger(__name__)
-
-
-async def simple_call_agent(query, runner, user_id=None, session_id=None):
-    if isinstance(query, str):
-        request = AgentRequest(
-            input=[
-                {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "text",
-                            "text": query,
-                        },
-                    ],
-                },
-            ],
-            session_id=session_id,
-        )
-    else:
-        request = query
-
-    all_result = ""
-    async for message in runner.stream_query(
-        user_id=user_id,
-        request=request,
-    ):
-        if (
-            message.object == "message"
-            and MessageType.MESSAGE == message.type
-            and RunStatus.Completed == message.status
-        ):
-            all_result = message.content[0].text
-
-    return all_result
-
-
-async def simple_call_agent_direct(agent, query):
-    async with create_context_manager() as context_manager:
-        runner = Runner(
-            agent=agent,
-            context_manager=context_manager,
-        )
-        result = await simple_call_agent(
-            query,
-            runner,
-        )
-    return result
-
-
-async def simple_call_agent_tool(agent, query):
-    if isinstance(query, str):
-        request = AgentRequest(
-            input=[
-                {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "text",
-                            "text": query,
-                        },
-                    ],
-                },
-            ],
-        )
-    else:
-        request = query
-
-    all_result = ""
-    async with create_context_manager() as context_manager:
-        async with create_environment_manager() as environment_manager:
-            runner = Runner(
-                agent=agent,
-                context_manager=context_manager,
-                environment_manager=environment_manager,
-            )
-
-            async for message in runner.stream_query(
-                request=request,
-            ):
-                if (
-                    message.object == "message"
-                    and MessageType.MESSAGE == message.type
-                    and RunStatus.Completed == message.status
-                ):
-                    all_result = message.content[0].text
-    return all_result
-
-
-async def simple_call_agent_tool_auto_lifecycle(agent, query):
-    if isinstance(query, str):
-        request = AgentRequest(
-            input=[
-                {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "text",
-                            "text": query,
-                        },
-                    ],
-                },
-            ],
-        )
-    else:
-        request = query
-
-    all_result = ""
-    async with Runner(
-        agent=agent,
-        context_manager=create_context_manager(),
-        environment_manager=create_environment_manager(),
-    ) as runner:
-        async for message in runner.stream_query(
-            request=request,
-        ):
-            if (
-                message.object == "message"
-                and MessageType.MESSAGE == message.type
-                and RunStatus.Completed == message.status
-            ):
-                all_result = message.content[0].text
-    return all_result
-
-
-async def simple_call_agent_tool_wo_env(agent, query):
-    if isinstance(query, str):
-        request = AgentRequest(
-            input=[
-                {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "text",
-                            "text": query,
-                        },
-                    ],
-                },
-            ],
-        )
-    else:
-        request = query
-
-    all_result = ""
-    async with create_context_manager() as context_manager:
-        runner = Runner(
-            agent=agent,
-            context_manager=context_manager,
-        )
-
-        async for message in runner.stream_query(
-            request=request,
-        ):
-            if (
-                message.object == "message"
-                and MessageType.MESSAGE == message.type
-                and RunStatus.Completed == message.status
-            ):
-                all_result = message.content[0].text
-
-            logger.debug(message.model_dump())
-
-    return all_result

agentscope_runtime/engine/schemas/context.py

@@ -1,54 +0,0 @@
-# -*- coding: utf-8 -*-
-from typing import Optional, List, Dict
-
-from pydantic import BaseModel, ConfigDict
-
-from .agent_schemas import AgentRequest
-from .agent_schemas import Message
-from ..agents.base_agent import Agent
-from ..services.context_manager import ContextManager
-
-from ..services.session_history_service import (
-    Session,
-)
-from ..services.environment_manager import EnvironmentManager
-
-
-class Context(BaseModel):
-    """
-    Holds all contextual information for a single agent invocation.
-
-    This object is created by the Runner and passed through the agent
-    execution flow, providing access to necessary services and data,
-    including a live request queue for real-time interaction.
-    """
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-        extra="forbid",
-    )
-
-    # Core context
-    user_id: str
-    session: Session = Session(id="", user_id="")
-    activate_tools: list = []
-    new_message: Optional[Message] = None
-    current_messages: List[Message] = []
-    request: AgentRequest
-    new_message_dict: Optional[Dict] = None
-    messages_list: List[Dict] = []
-
-    # Services available to the agent
-
-    environment_manager: Optional[EnvironmentManager] = None
-    context_manager: Optional[ContextManager] = None
-    # Agent specific config
-    agent: Agent
-    agent_config: Optional[dict] = None
-
-    @property
-    def messages(self):
-        if self.new_message_dict:
-            return self.messages_list + [self.new_message_dict]
-        else:
-            return self.messages_list

agentscope_runtime/engine/services/context_manager.py

@@ -1,164 +0,0 @@
-# -*- coding: utf-8 -*-
-from contextlib import asynccontextmanager
-from typing import List
-
-from .manager import ServiceManager
-from .memory_service import MemoryService, InMemoryMemoryService
-from .rag_service import RAGService
-from .session_history_service import (
-    SessionHistoryService,
-    Session,
-    InMemorySessionHistoryService,
-)
-from ..schemas.agent_schemas import (
-    Message,
-    MessageType,
-    Role,
-    TextContent,
-    ContentType,
-)
-
-
-class ContextComposer:
-    @staticmethod
-    async def compose(
-        request_input: List[Message],  # current input
-        session: Session,  # session
-        memory_service: MemoryService = None,
-        session_history_service: SessionHistoryService = None,
-        rag_service: RAGService = 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
-
-        # rag
-        if rag_service:
-            query = await rag_service.get_query_text(request_input[-1])
-            docs = await rag_service.retrieve(query=query, k=5)
-            cooked_doc = "\n".join(docs)
-            message = Message(
-                type=MessageType.MESSAGE,
-                role=Role.SYSTEM,
-                content=[TextContent(type=ContentType.TEXT, text=cooked_doc)],
-            )
-            if len(session.messages) >= 1:
-                last_message = session.messages[-1]
-                session.messages.remove(last_message)
-                session.messages.append(message)
-                session.messages.append(last_message)
-            else:
-                session.messages.append(message)
-
-
-class ContextManager(ServiceManager):
-    """
-    The contextManager class
-    """
-
-    def __init__(
-        self,
-        context_composer_cls=ContextComposer,
-        session_history_service: SessionHistoryService = None,
-        memory_service: MemoryService = None,
-        rag_service: RAGService = None,
-    ):
-        self._context_composer_cls = context_composer_cls
-        self._session_history_service = session_history_service
-        self._memory_service = memory_service
-        self._rag_service = rag_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)
-        if self._rag_service:
-            self.register_service("rag", self._rag_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,
-            rag_service=self._rag_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,
-    rag_service: RAGService = None,
-    context_composer_cls=ContextComposer,
-):
-    manager = ContextManager(
-        memory_service=memory_service,
-        session_history_service=session_history_service,
-        rag_service=rag_service,
-        context_composer_cls=context_composer_cls,
-    )
-
-    async with manager:
-        yield manager