agentscope-runtime 1.0.3__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/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:
 

agentscope_runtime/engine/services/agent_state/redis_state_service.py

@@ -23,7 +23,7 @@ class RedisStateService(StateService):
         redis_client: Optional[aioredis.Redis] = None,
         socket_timeout: Optional[float] = 5.0,
         socket_connect_timeout: Optional[float] = 5.0,
-        max_connections: Optional[int] = 50,
+        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,
@@ -39,7 +39,7 @@ class RedisStateService(StateService):
             socket_connect_timeout: Socket connect timeout in seconds
             (default: 5.0)
             max_connections: Maximum number of connections in the pool
-            (default: 50)
+            (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)

agentscope_runtime/engine/services/memory/redis_memory_service.py

@@ -19,7 +19,7 @@ class RedisMemoryService(MemoryService):
         redis_client: Optional[aioredis.Redis] = None,
         socket_timeout: Optional[float] = 5.0,
         socket_connect_timeout: Optional[float] = 5.0,
-        max_connections: Optional[int] = 50,
+        max_connections: Optional[int] = None,
         retry_on_timeout: bool = True,
         ttl_seconds: Optional[int] = 3600,  # 1 hour in seconds
         max_messages_per_session: Optional[int] = None,
@@ -36,7 +36,7 @@ class RedisMemoryService(MemoryService):
             socket_connect_timeout: Socket connect timeout in seconds
              (default: 5.0)
             max_connections: Maximum number of connections in the pool
-             (default: 50)
+             (default: None)
             retry_on_timeout: Whether to retry on timeout (default: True)
             ttl_seconds: Time-to-live in seconds for memory data.
             If None, data never expires (default: 3600, i.e., 1 hour)

agentscope_runtime/engine/services/session_history/redis_session_history_service.py

@@ -17,7 +17,7 @@ class RedisSessionHistoryService(SessionHistoryService):
         redis_client: Optional[aioredis.Redis] = None,
         socket_timeout: Optional[float] = 5.0,
         socket_connect_timeout: Optional[float] = 5.0,
-        max_connections: Optional[int] = 50,
+        max_connections: Optional[int] = None,
         retry_on_timeout: bool = True,
         ttl_seconds: Optional[int] = 3600,  # 1 hour in seconds
         max_messages_per_session: Optional[int] = None,
@@ -34,7 +34,7 @@ class RedisSessionHistoryService(SessionHistoryService):
             socket_connect_timeout: Socket connect timeout in seconds
             (default: 5.0)
             max_connections: Maximum number of connections in the pool
-            (default: 50)
+            (default: None)
             retry_on_timeout: Whether to retry on timeout (default: True)
             ttl_seconds: Time-to-live in seconds for session data.
             If None, data never expires (default: 3600, i.e., 1 hour)

agentscope_runtime/engine/tracing/wrapper.py

@@ -26,7 +26,11 @@ from typing import (
 from pydantic import BaseModel
 from opentelemetry.propagate import extract
 from opentelemetry.context import attach
-from opentelemetry.trace import StatusCode, NoOpTracerProvider
+from opentelemetry.trace import (
+    ProxyTracerProvider,
+    StatusCode,
+    NoOpTracerProvider,
+)
 from opentelemetry import trace as ot_trace
 from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
     OTLPSpanExporter as OTLPSpanGrpcExporter,
@@ -917,12 +921,22 @@ def _get_ot_tracer() -> ot_trace.Tracer:
         ot_trace.Tracer: The OpenTelemetry tracer instance.
     """
 
-    def _get_ot_tracer_inner() -> ot_trace.Tracer:
+    def _has_existing_trace_provider() -> bool:
+        from opentelemetry.trace import _TRACER_PROVIDER
+
         existing_provider = ot_trace.get_tracer_provider()
+        if isinstance(existing_provider, NoOpTracerProvider):
+            return False
+        elif isinstance(existing_provider, ProxyTracerProvider):
+            # ProxyTracerProvider will use the _TRACER_PROVIDER as real tracer
+            # provider to get the tracer
+            return bool(_TRACER_PROVIDER)
 
-        if not isinstance(existing_provider, NoOpTracerProvider):
-            return ot_trace.get_tracer("agentscope_runtime")
+        return True
 
+    def _get_ot_tracer_inner() -> ot_trace.Tracer:
+        if _has_existing_trace_provider():
+            return ot_trace.get_tracer("agentscope_runtime")
         resource = Resource(
             attributes={
                 SERVICE_NAME: _get_service_name(),

agentscope_runtime/sandbox/__init__.py

@@ -3,22 +3,30 @@
 # This ensures SandboxRegistry.register() runs at import time.
 # Without this, lazy loading delays module import and types may not be
 # registered.
-from .box.base.base_sandbox import BaseSandbox
-from .box.browser.browser_sandbox import BrowserSandbox
-from .box.filesystem.filesystem_sandbox import FilesystemSandbox
-from .box.gui.gui_sandbox import GuiSandbox
+from .box.base.base_sandbox import BaseSandbox, BaseSandboxAsync
+from .box.browser.browser_sandbox import BrowserSandbox, BrowserSandboxAsync
+from .box.filesystem.filesystem_sandbox import (
+    FilesystemSandbox,
+    FilesystemSandboxAsync,
+)
+from .box.gui.gui_sandbox import GuiSandbox, GuiSandboxAsync
+from .box.mobile.mobile_sandbox import MobileSandbox, MobileSandboxAsync
 from .box.training_box.training_box import TrainingSandbox
 from .box.cloud.cloud_sandbox import CloudSandbox
-from .box.mobile.mobile_sandbox import MobileSandbox
 from .box.agentbay.agentbay_sandbox import AgentbaySandbox
 
 __all__ = [
     "BaseSandbox",
+    "BaseSandboxAsync",
     "BrowserSandbox",
+    "BrowserSandboxAsync",
     "FilesystemSandbox",
+    "FilesystemSandboxAsync",
     "GuiSandbox",
+    "GuiSandboxAsync",
+    "MobileSandbox",
+    "MobileSandboxAsync",
     "TrainingSandbox",
     "CloudSandbox",
-    "MobileSandbox",
     "AgentbaySandbox",
 ]

agentscope_runtime/sandbox/box/base/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
-from .base_sandbox import BaseSandbox
+from .base_sandbox import BaseSandbox, BaseSandboxAsync
 
-__all__ = ["BaseSandbox"]
+__all__ = ["BaseSandbox", "BaseSandboxAsync"]

agentscope_runtime/sandbox/box/base/base_sandbox.py

@@ -4,7 +4,7 @@ from typing import Optional
 from ...utils import build_image_uri
 from ...registry import SandboxRegistry
 from ...enums import SandboxType
-from ...box.sandbox import Sandbox
+from ...box.sandbox import Sandbox, SandboxAsync
 from ...constant import TIMEOUT
 
 
@@ -49,3 +49,53 @@ class BaseSandbox(Sandbox):
             command (str): Shell command to execute.
         """
         return self.call_tool("run_shell_command", {"command": command})
+
+
+@SandboxRegistry.register(
+    build_image_uri("runtime-sandbox-base"),
+    sandbox_type=SandboxType.BASE_ASYNC,
+    security_level="medium",
+    timeout=TIMEOUT,
+    description="Base Sandbox (Async)",
+)
+class BaseSandboxAsync(SandboxAsync):
+    def __init__(
+        self,
+        sandbox_id: Optional[str] = None,
+        timeout: int = 3000,
+        base_url: Optional[str] = None,
+        bearer_token: Optional[str] = None,
+        sandbox_type: SandboxType = SandboxType.BASE_ASYNC,
+    ):
+        super().__init__(
+            sandbox_id,
+            timeout,
+            base_url,
+            bearer_token,
+            sandbox_type,
+        )
+
+    async def run_ipython_cell(self, code: str):
+        """
+        Run an IPython cell asynchronously.
+
+        Args:
+            code (str): IPython code to execute.
+        Returns:
+            Any: Response from sandbox execution
+        """
+        return await self.call_tool_async("run_ipython_cell", {"code": code})
+
+    async def run_shell_command(self, command: str):
+        """
+        Run a shell command asynchronously.
+
+        Args:
+            command (str): Shell command to execute.
+        Returns:
+            Any: Response from sandbox execution
+        """
+        return await self.call_tool_async(
+            "run_shell_command",
+            {"command": command},
+        )

agentscope_runtime/sandbox/box/browser/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
-from .browser_sandbox import BrowserSandbox
+from .browser_sandbox import BrowserSandbox, BrowserSandboxAsync
 
-__all__ = ["BrowserSandbox"]
+__all__ = ["BrowserSandbox", "BrowserSandboxAsync"]