agentscope-runtime 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl

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

@@ -0,0 +1,220 @@
+# -*- 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/deployers/utils/service_utils/standalone_main.py.j2

@@ -0,0 +1,211 @@
+import os
+import sys
+
+# Add current directory and handler directories to Python path for local module imports
+current_dir = os.path.dirname(os.path.abspath(__file__))
+if current_dir not in sys.path:
+    sys.path.insert(0, current_dir)
+
+{% if handler_dirs %}
+# Add copied handler directories to sys.path
+{% for handler_dir in handler_dirs %}
+handler_dir_path = os.path.join(current_dir, "{{handler_dir}}")
+if os.path.isdir(handler_dir_path) and handler_dir_path not in sys.path:
+    sys.path.insert(0, handler_dir_path)
+{% endfor %}
+{% endif %}
+
+import uvicorn
+from agentscope_runtime.engine.deployers.utils.deployment_modes import DeploymentMode
+from agentscope_runtime.engine.deployers.utils.service_utils import (
+    FastAPIAppFactory,
+    ServicesConfig,
+    ServiceConfig,
+)
+from agentscope_runtime.engine.schemas.agent_schemas import AgentRequest
+from typing import Callable, Optional, Dict, List, Any, Union
+
+from agent_file import {{agent_name}} as agent
+{% if protocol_adapters %}{{protocol_adapters}}{% endif %}
+
+{% if custom_endpoints %}
+# Custom endpoint imports
+{% for endpoint in custom_endpoints %}
+{% if endpoint.handler_module and endpoint.function_name %}
+from {{endpoint.handler_module}} import {{endpoint.function_name}}
+{% elif endpoint.module and endpoint.function_name %}
+from agent_file import {{endpoint.function_name}}
+{% endif %}
+{% endfor %}
+{% endif %}
+
+
+
+def load_services_config() -> ServicesConfig:
+    """Load services configuration from environment variables or config file."""
+    config_file = os.getenv('AGENTSCOPE_SERVICES_CONFIG')
+
+    if config_file and os.path.exists(config_file):
+        # Load from JSON config file
+        import json
+        with open(config_file, 'r', encoding='utf-8') as f:
+            config_data = json.load(f)
+            return ServicesConfig.model_validate(config_data)
+    else:
+        # Load from environment variables
+        memory_provider = os.getenv('MEMORY_PROVIDER', 'in_memory')
+        session_provider = os.getenv('SESSION_HISTORY_PROVIDER', 'in_memory')
+
+        memory_config = {}
+        session_config = {}
+
+        # Add Redis configuration if using Redis
+        if memory_provider == 'redis':
+            memory_config = {
+                'host': os.getenv('REDIS_HOST', 'localhost'),
+                'port': int(os.getenv('REDIS_PORT', 6379)),
+                'db': int(os.getenv('REDIS_MEMORY_DB', 0))
+            }
+
+        if session_provider == 'redis':
+            session_config = {
+                'host': os.getenv('REDIS_HOST', 'localhost'),
+                'port': int(os.getenv('REDIS_PORT', 6379)),
+                'db': int(os.getenv('REDIS_SESSION_DB', 1))
+            }
+
+        return ServicesConfig(
+            memory=ServiceConfig(provider=memory_provider, config=memory_config),
+            session_history=ServiceConfig(provider=session_provider, config=session_config)
+        )
+
+
+def load_celery_config():
+    """Load Celery configuration from environment variables or infer from existing config."""
+    celery_config = {
+        'broker_url': None,
+        'backend_url': None,
+        'enable_embedded_worker': False,
+        'redis_available': False
+    }
+
+    {% if celery_config %}
+    # Apply inline Celery configuration
+    {{celery_config}}
+    {% endif %}
+
+    if not celery_config.get('broker_url') or not celery_config.get('backend_url'):
+        redis_host = os.getenv('REDIS_HOST', 'localhost')
+        redis_port = os.getenv('REDIS_PORT', '6379')
+
+        # Use different databases for different purposes
+        broker_db = os.getenv('CELERY_BROKER_DB', '2')  # Default DB 2 for Celery broker
+        backend_db = os.getenv('CELERY_BACKEND_DB', '3')  # Default DB 3 for Celery backend
+
+        # Auto-generate URLs if Redis is available
+        if not celery_config.get('broker_url'):
+            celery_config['broker_url'] = f"redis://{redis_host}:{redis_port}/{broker_db}"
+        if not celery_config.get('backend_url'):
+            celery_config['backend_url'] = f"redis://{redis_host}:{redis_port}/{backend_db}"
+
+    return celery_config
+
+
+def _check_redis_availability(redis_url: str) -> bool:
+    """Check if Redis is available at the given URL."""
+    try:
+        import redis
+        from urllib.parse import urlparse
+
+        parsed = urlparse(redis_url)
+        host = parsed.hostname or 'localhost'
+        port = parsed.port or 6379
+
+        r = redis.Redis(host=host, port=port, socket_connect_timeout=2)
+        r.ping()
+        return True
+    except Exception:
+        return False
+
+
+{% if custom_endpoints %}
+def setup_custom_endpoints():
+    """Setup custom endpoints configuration."""
+    custom_endpoints = [
+        {% for endpoint in custom_endpoints %}
+        {
+            "path": "{{endpoint.path}}",
+            "handler": {% if endpoint.handler_module or endpoint.module %}{{endpoint.function_name}}{% else %}{{endpoint.inline_code|default('lambda request: {"error": "Handler not available"}')}}{% endif %},
+            "methods": {{endpoint.methods}}
+        },
+        {% endfor %}
+    ]
+    return custom_endpoints
+{% endif %}
+
+
+async def setup_runner_with_agent(app):
+    """Setup runner with the agent instance."""
+    if hasattr(app.state, 'runner') and app.state.runner:
+        # Set the agent on the runner
+        app.state.runner._agent = agent
+
+
+async def before_start(app, **kwargs):
+    """Application startup callback."""
+    await setup_runner_with_agent(app)
+
+
+async def after_finish(app, **kwargs):
+    """Application shutdown callback."""
+    # Runner cleanup is handled by the factory
+    pass
+
+
+# Load services configuration
+services_config = load_services_config()
+
+# Load Celery configuration
+celery_config = load_celery_config()
+
+# Determine deployment mode from environment or use default
+deployment_mode_str = os.getenv('DEPLOYMENT_MODE', '{{deployment_mode|default("standalone")}}')
+if deployment_mode_str == 'detached_process':
+    deployment_mode = DeploymentMode.DETACHED_PROCESS
+elif deployment_mode_str == 'standalone':
+    deployment_mode = DeploymentMode.STANDALONE
+else:
+    deployment_mode = DeploymentMode.STANDALONE  # fallback
+
+# Create FastAPI application using the factory
+app = FastAPIAppFactory.create_app(
+    endpoint_path="{{endpoint_path}}",
+    mode=deployment_mode,
+    services_config=services_config,
+    before_start=before_start,
+    after_finish=after_finish,
+    stream=True,
+    broker_url=celery_config['broker_url'],
+    backend_url=celery_config['backend_url'],
+    enable_embedded_worker=celery_config['enable_embedded_worker']{% if protocol_adapters %},
+    protocol_adapters=protocol_adapters{% endif %}{% if custom_endpoints %},
+    custom_endpoints=setup_custom_endpoints(){% endif %}
+)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="AgentScope Runtime Standalone Service")
+    parser.add_argument("--host", default="0.0.0.0", help="Host to bind to")
+    parser.add_argument("--port", type=int, default=8080, help="Port to bind to")
+    parser.add_argument("--workers", type=int, default=1, help="Number of worker processes")
+
+    args = parser.parse_args()
+
+    uvicorn.run(
+        app,
+        host=args.host,
+        port=args.port,
+        workers=args.workers if args.workers > 1 else None
+    )