agentscope-runtime 1.0.2__py3-none-any.whl → 1.0.4__py3-none-any.whl

agentscope_runtime/engine/deployers/knative_deployer.py

@@ -0,0 +1,290 @@
+# -*- coding: utf-8 -*-
+import logging
+import os
+from typing import Optional, Dict, List, Union, Any
+
+from pydantic import BaseModel, Field
+from .utils.docker_image_utils import (
+    ImageFactory,
+    RegistryConfig,
+)
+from .adapter.protocol_adapter import ProtocolAdapter
+from .base import DeployManager
+from ...common.container_clients.knative_client import (
+    KnativeClient,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class K8sConfig(BaseModel):
+    # Kubernetes settings
+    k8s_namespace: Optional[str] = Field(
+        "agentscope-runtime",
+        description="Kubernetes namespace to deploy KService. ",
+    )
+    kubeconfig_path: Optional[str] = Field(
+        None,
+        description="Path to kubeconfig file. If not set, will try "
+        "in-cluster config or default kubeconfig.",
+    )
+
+
+class BuildConfig(BaseModel):
+    """Build configuration"""
+
+    build_context_dir: str = "/tmp/k8s_build"
+    dockerfile_template: str = None
+    build_timeout: int = 600  # 10 minutes
+    push_timeout: int = 300  # 5 minutes
+    cleanup_after_build: bool = True
+
+
+class KnativeDeployManager(DeployManager):
+    """
+    Deploy an AgentScope runner as a Knative Service.
+    Requires a Kubernetes cluster with Knative Serving installed.
+    """
+
+    def __init__(
+        self,
+        kube_config: K8sConfig = None,
+        registry_config: RegistryConfig = RegistryConfig(),
+        build_context_dir: str = "/tmp/k8s_build",
+    ):
+        """
+        Initialize the Knative deployer.
+        """
+        super().__init__()
+        self.kubeconfig = kube_config
+        self.registry_config = registry_config
+        self.image_factory = ImageFactory()
+        self.build_context_dir = build_context_dir
+        self._deployed_resources = {}
+        self._built_images = {}
+
+        self.knative_client = KnativeClient(
+            config=self.kubeconfig,
+            image_registry=self.registry_config.get_full_url(),
+        )
+
+    async def deploy(
+        self,
+        app=None,
+        runner=None,
+        stream: bool = True,
+        protocol_adapters: Optional[list[ProtocolAdapter]] = None,
+        requirements: Optional[Union[str, List[str]]] = None,
+        extra_packages: Optional[List[str]] = None,
+        base_image: str = "python:3.9-slim",
+        environment: Dict = None,
+        runtime_config: Dict = None,
+        annotations: Dict = None,
+        labels: Dict = None,
+        port: int = 8080,
+        mount_dir: str = None,
+        image_name: str = "agent_llm",
+        image_tag: str = "latest",
+        push_to_registry: bool = False,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Deploy the runner as a Knative Service.
+
+        Args:
+            app: Agent app to be deployed
+            runner: Complete Runner object with agent, environment_manager,
+                context_manager
+            stream: Enable streaming responses
+            protocol_adapters: protocol adapters
+            requirements: PyPI dependencies (following _agent_engines.py
+                pattern)
+            extra_packages: User code directory/file path
+            base_image: Docker base image
+            port: Container port
+            environment: Environment variables dict
+            mount_dir: Mount directory
+            runtime_config: K8s runtime configuration
+            annotations: knative service annotations
+            labels: knative service labels
+            # Backward compatibility
+            image_name: Image name
+            image_tag: Image tag
+            push_to_registry: Push to registry
+            **kwargs: Additional arguments
+
+        Returns:
+            Dict containing deploy_id, url, resource_name
+
+        Raises:
+            RuntimeError: If kservice fails
+
+        """
+        created_resources = []
+        deploy_id = self.deploy_id
+        try:
+            logger.info(f"Starting Knative Service {deploy_id}")
+
+            # Step 1: Build image with proper error handling
+            logger.info("Building runner image...")
+            try:
+                built_image_name = self.image_factory.build_image(
+                    app=app,
+                    runner=runner,
+                    base_image=base_image,
+                    build_context_dir=self.build_context_dir,
+                    registry_config=self.registry_config,
+                    image_name=image_name,
+                    image_tag=image_tag,
+                    push_to_registry=push_to_registry,
+                    port=port,
+                    protocol_adapters=protocol_adapters,
+                    **kwargs,
+                )
+                if not built_image_name:
+                    raise RuntimeError(
+                        "Image build failed - no image name returned",
+                    )
+
+                created_resources.append(f"image:{built_image_name}")
+                self._built_images[deploy_id] = built_image_name
+                logger.info(f"Image built successfully: {built_image_name}")
+            except Exception as e:
+                logger.error(f"Image build failed: {e}")
+                raise RuntimeError(f"Failed to build image: {e}") from e
+
+            if mount_dir:
+                if not os.path.isabs(mount_dir):
+                    mount_dir = os.path.abspath(mount_dir)
+
+                volume_bindings = {
+                    mount_dir: {
+                        "bind": mount_dir,
+                        "mode": "rw",
+                    },
+                }
+            else:
+                volume_bindings = {}
+
+            resource_name = self.get_resource_name(deploy_id)
+
+            logger.info(f"Building Knative Service for {deploy_id}")
+
+            # Create Knative Service
+            name, url = self.knative_client.create_kservice(
+                name=resource_name,
+                image=built_image_name,
+                ports=[port],
+                volumes=volume_bindings,
+                environment=environment,
+                runtime_config=runtime_config or {},
+                annotations=annotations or {},
+                labels=labels or {},
+            )
+            if not url:
+                import traceback
+
+                raise RuntimeError(
+                    f"Failed to create resource: "
+                    f"{resource_name}, {traceback.format_exc()}",
+                )
+
+            logger.info(f"Knative Service url {url} successful")
+            self._deployed_resources[deploy_id] = {
+                "resource_name": name,
+                "config": {
+                    "runner": runner.__class__.__name__,
+                    "extra_packages": extra_packages,
+                    "requirements": requirements,  # New format
+                    "base_image": base_image,
+                    "port": port,
+                    "environment": environment,
+                    "runtime_config": runtime_config,
+                    "stream": stream,
+                    "protocol_adapters": protocol_adapters,
+                    **kwargs,
+                },
+            }
+            return {
+                "deploy_id": deploy_id,
+                "resource_name": resource_name,
+                "url": url,
+            }
+
+        except Exception as e:
+            import traceback
+
+            logger.error(f"Knative Service {deploy_id} failed: {e}")
+            # Enhanced rollback with better error handling
+            raise RuntimeError(
+                f"Knative Service failed: {e}, {traceback.format_exc()}",
+            ) from e
+
+    @staticmethod
+    def get_resource_name(deploy_id: str) -> str:
+        return f"agent-{deploy_id[:8]}"
+
+    async def stop(
+        self,
+        deploy_id: str,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Stop Knative Service.
+
+        Args:
+            deploy_id: Deployment identifier
+            **kwargs: Additional parameters
+
+        Returns:
+            Dict with success status, message, and details
+        """
+
+        resource_name = self.get_resource_name(deploy_id)
+        try:
+            # Try to remove the KService
+            success = self.knative_client.delete_kservice(resource_name)
+
+            if success:
+                return {
+                    "success": True,
+                    "message": f"Knative deployment {resource_name} "
+                    f"removed",
+                    "details": {
+                        "deploy_id": deploy_id,
+                        "resource_name": resource_name,
+                    },
+                }
+            else:
+                return {
+                    "success": False,
+                    "message": f"Knative deployment {resource_name} not "
+                    f"found (may already be deleted), Please check the "
+                    f"detail in cluster",
+                    "details": {
+                        "deploy_id": deploy_id,
+                        "resource_name": resource_name,
+                    },
+                }
+        except Exception as e:
+            logger.error(
+                f"Failed to remove Knative service {resource_name}: {e}",
+            )
+            return {
+                "success": False,
+                "message": f"Failed to remove Knative service: {e}",
+                "details": {
+                    "deploy_id": deploy_id,
+                    "resource_name": resource_name,
+                    "error": str(e),
+                },
+            }
+
+    def get_status(self) -> str:
+        """Get KService status"""
+        if self.deploy_id not in self._deployed_resources:
+            return "not_found"
+
+        resources = self._deployed_resources[self.deploy_id]
+        kservice_name = resources["resource_name"]
+
+        return self.knative_client.get_kservice_status(kservice_name)

agentscope_runtime/engine/deployers/kubernetes_deployer.py

@@ -144,6 +144,7 @@ class KubernetesDeployManager(DeployManager):
         image_tag: str = "latest",
         push_to_registry: bool = False,
         use_cache: bool = True,
+        pypi_mirror: Optional[str] = None,
         **kwargs,
     ) -> Dict[str, Any]:
         """
@@ -170,6 +171,7 @@ class KubernetesDeployManager(DeployManager):
             mount_dir: Mount directory
             runtime_config: K8s runtime configuration
             use_cache: Enable build cache (default: True)
+            pypi_mirror: PyPI mirror URL for pip package installation
             # Backward compatibility
             image_name: Image name
             image_tag: Image tag
@@ -209,6 +211,7 @@ class KubernetesDeployManager(DeployManager):
                     protocol_adapters=protocol_adapters,
                     custom_endpoints=custom_endpoints,
                     use_cache=use_cache,
+                    pypi_mirror=pypi_mirror,
                     **kwargs,
                 )
                 if not built_image_name:

agentscope_runtime/engine/deployers/utils/docker_image_utils/dockerfile_generator.py

@@ -22,6 +22,7 @@ class DockerfileConfig(BaseModel):
     health_check_endpoint: str = "/health"
     custom_template: Optional[str] = None
     platform: Optional[str] = None
+    pypi_mirror: Optional[str] = None
 
 
 class DockerfileGenerator:
@@ -73,8 +74,7 @@ COPY . {working_dir}/
 # Install Python dependencies
 RUN pip install --no-cache-dir --upgrade pip
 RUN if [ -f requirements.txt ]; then \\
-        pip install --no-cache-dir -r requirements.txt \\
-        -i https://pypi.tuna.tsinghua.edu.cn/simple; fi
+        pip install --no-cache-dir -r requirements.txt{pypi_mirror_flag}; fi
 
 # Create non-root user for security
 RUN adduser --disabled-password --gecos '' {user} && \\
@@ -136,6 +136,11 @@ HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \\
                 f'"--port", "{config.port}"]'
             )
 
+        # Prepare PyPI mirror flag
+        pypi_mirror_flag = ""
+        if config.pypi_mirror:
+            pypi_mirror_flag = f" -i {config.pypi_mirror}"
+
         # Format template with configuration values
         content = template.format(
             base_image=config.base_image,
@@ -147,6 +152,7 @@ HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \\
             env_vars_section=env_vars_section,
             startup_command_section=startup_command_section,
             platform=config.platform,
+            pypi_mirror_flag=pypi_mirror_flag,
         )
 
         return content

agentscope_runtime/engine/deployers/utils/docker_image_utils/image_factory.py

@@ -40,6 +40,7 @@ class ImageConfig(BaseModel):
     port: int = 8000
     env_vars: Dict[str, str] = Field(default_factory=lambda: {})
     startup_command: Optional[str] = None
+    pypi_mirror: Optional[str] = None
 
     # Runtime configuration
     host: str = "0.0.0.0"  # Container-friendly default
@@ -218,6 +219,7 @@ class ImageFactory:
                 env_vars=config.env_vars,
                 startup_command=startup_command,
                 platform=config.platform,
+                pypi_mirror=config.pypi_mirror,
             )
 
             dockerfile_path = self.dockerfile_generator.create_dockerfile(
@@ -314,6 +316,7 @@ class ImageFactory:
         embed_task_processor: bool = True,
         extra_startup_args: Optional[Dict[str, Union[str, int, bool]]] = None,
         use_cache: bool = True,
+        pypi_mirror: Optional[str] = None,
         **kwargs,
     ) -> str:
         """
@@ -339,6 +342,7 @@ class ImageFactory:
             embed_task_processor: Whether to embed task processor
             extra_startup_args: Additional startup arguments
             use_cache: Enable build cache (default: True)
+            pypi_mirror: PyPI mirror URL for pip package installation
             **kwargs: Additional configuration options
 
         Returns:
@@ -373,6 +377,7 @@ class ImageFactory:
             host=host,
             embed_task_processor=embed_task_processor,
             extra_startup_args=extra_startup_args or {},
+            pypi_mirror=pypi_mirror,
             **kwargs,
         )
 

agentscope_runtime/engine/deployers/utils/net_utils.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+import ipaddress
+import os
+import socket
+from typing import Optional
+
+import psutil
+
+
+def get_first_non_loopback_ip() -> Optional[str]:
+    """Get the first non-loopback IP address from network interfaces.
+
+    - Selects the interface with the lowest index
+    - Only considers interfaces that are up
+    - Supports IPv4/IPv6 based on environment variable
+    - Falls back to socket.gethostbyname() if no address found
+
+    Returns:
+        str | None: The first non-loopback IP address, or None if not found
+    """
+    result = None
+    lowest_index = float("inf")
+
+    use_ipv6 = os.environ.get("USE_IPV6", "false").lower() == "true"
+    target_family = socket.AF_INET6 if use_ipv6 else socket.AF_INET
+
+    net_if_stats = psutil.net_if_stats()
+
+    for index, (interface, addrs) in enumerate(
+        psutil.net_if_addrs().items(),
+    ):
+        stats = net_if_stats.get(interface)
+        if stats is None or not stats.isup:
+            continue
+
+        if index < lowest_index or result is None:
+            lowest_index = index
+        else:
+            continue
+
+        for addr in addrs:
+            if addr.family != target_family:
+                continue
+
+            try:
+                ip_obj = ipaddress.ip_address(
+                    addr.address.split("%")[0],
+                )
+                if ip_obj.is_loopback:
+                    continue
+                result = addr.address
+            except ValueError:
+                continue
+
+    if result is not None:
+        return result
+
+    try:
+        hostname = socket.gethostname()
+        fallback_ip = socket.gethostbyname(hostname)
+        return fallback_ip
+    except socket.error:
+        pass
+
+    return None

agentscope_runtime/engine/runner.py

@@ -272,6 +272,18 @@ class Runner:
             kwargs.update(
                 {"msgs": await message_to_agno_message(request.input)},
             )
+        elif self.framework_type == "ms_agent_framework":
+            from ..adapters.ms_agent_framework.stream import (
+                adapt_ms_agent_framework_message_stream,
+            )
+            from ..adapters.ms_agent_framework.message import (
+                message_to_ms_agent_framework_message,
+            )
+
+            stream_adapter = adapt_ms_agent_framework_message_stream
+            kwargs.update(
+                {"msgs": message_to_ms_agent_framework_message(request.input)},
+            )
         # TODO: support other frameworks
         else:
 
@@ -282,6 +294,7 @@ class Runner:
 
             stream_adapter = identity_stream_adapter
 
+        error = None
         try:
             async for event in stream_adapter(
                 source_stream=self._call_handler_streaming(
@@ -301,8 +314,6 @@ class Runner:
                 e = UnknownAgentException(original_exception=e)
             error = Error(code=e.code, message=e.message)
             logger.error(f"{error.model_dump()}: {traceback.format_exc()}")
-            yield seq_gen.yield_with_sequence(response.failed(error))
-            return
 
         # Obtain token usage
         try:
@@ -312,4 +323,7 @@ class Runner:
             # Avoid empty message
             pass
 
-        yield seq_gen.yield_with_sequence(response.completed())
+        if error:
+            yield seq_gen.yield_with_sequence(response.failed(error))
+        else:
+            yield seq_gen.yield_with_sequence(response.completed())

agentscope_runtime/engine/schemas/exception.py

@@ -578,3 +578,27 @@ class UnknownAgentException(AgentRuntimeErrorException):
             message,
             details,
         )
+
+
+class ModelQuotaExceededException(AgentRuntimeErrorException):
+    """Model quota exceeded"""
+
+    def __init__(
+        self,
+        model_name: str,
+        details: Optional[Dict[str, Any]] = None,
+    ):
+        message = f"Model quota exceeded: {model_name}"
+        super().__init__("MODEL_QUOTA_EXCEEDED", message, details)
+
+
+class ModelContextLengthExceededException(AgentRuntimeErrorException):
+    """Model context length exceeded"""
+
+    def __init__(
+        self,
+        model_name: str,
+        details: Optional[Dict[str, Any]] = None,
+    ):
+        message = f"Model context length exceeded: {model_name}"
+        super().__init__("MODEL_CONTEXT_LENGTH_EXCEEDED", message, details)

agentscope_runtime/engine/services/agent_state/redis_state_service.py

@@ -21,29 +21,68 @@ class RedisStateService(StateService):
         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._health = False
+        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:
-        """Initialize the Redis connection."""
+        """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,
             )
-        self._health = True
 
     async def stop(self) -> None:
-        """Close the Redis connection."""
+        """Closes the Redis connection."""
         if self._redis:
-            await self._redis.close()
+            await self._redis.aclose()
             self._redis = None
-        self._health = False
 
     async def health(self) -> bool:
-        """Service health check."""
+        """Checks the health of the service."""
         if not self._redis:
             return False
         try:
@@ -81,6 +120,11 @@ class RedisStateService(StateService):
                 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(
@@ -110,4 +154,13 @@ class RedisStateService(StateService):
 
         if state_json is None:
             return None
-        return json.loads(state_json)
+
+        # 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_factory.py

@@ -43,13 +43,10 @@ class StateServiceFactory(ServiceFactory[StateService]):
 
 StateServiceFactory.register_backend(
     "in_memory",
-    lambda **kwargs: InMemoryStateService(),
+    InMemoryStateService,
 )
 
 StateServiceFactory.register_backend(
     "redis",
-    lambda **kwargs: RedisStateService(
-        redis_url=kwargs.get("redis_url", "redis://localhost:6379/0"),
-        redis_client=kwargs.get("redis_client"),
-    ),
+    RedisStateService,
 )