agentscope-runtime 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

agentscope_runtime/engine/deployers/agentrun_deployer.py

@@ -7,6 +7,7 @@ import logging
 import os
 import time
 from dataclasses import dataclass
+from datetime import datetime
 from pathlib import Path
 from typing import Dict, Optional, List, Any, Union, Tuple
 
@@ -34,7 +35,9 @@ from pydantic import BaseModel, Field
 from .adapter.protocol_adapter import ProtocolAdapter
 from .base import DeployManager
 from .local_deployer import LocalDeployManager
+from .state import Deployment
 from .utils.detached_app import get_bundle_entry_script
+from .utils.package import generate_build_directory
 from .utils.wheel_packager import (
     default_deploy_name,
     generate_wrapper_project,
@@ -95,7 +98,7 @@ class AgentRunConfig(BaseModel):
 
     execution_role_arn: Optional[str] = None
 
-    session_concurrency_limit: Optional[int] = 1
+    session_concurrency_limit: Optional[int] = 200
     session_idle_timeout_seconds: Optional[int] = 3600
 
     @classmethod
@@ -147,7 +150,7 @@ class AgentRunConfig(BaseModel):
 
         session_concurrency_limit_str = os.environ.get(
             "AGENT_RUN_SESSION_CONCURRENCY_LIMIT",
-            "1",
+            "200",
         )
         session_idle_timeout_seconds_str = os.environ.get(
             "AGENT_RUN_SESSION_IDLE_TIMEOUT_SECONDS",
@@ -218,6 +221,7 @@ class OSSConfig(BaseModel):
     region: str = Field("cn-hangzhou", description="OSS region")
     access_key_id: Optional[str] = None
     access_key_secret: Optional[str] = None
+    bucket_name: str
 
     @classmethod
     def from_env(cls) -> "OSSConfig":
@@ -236,6 +240,7 @@ class OSSConfig(BaseModel):
                 "OSS_ACCESS_KEY_SECRET",
                 os.environ.get("ALIBABA_CLOUD_ACCESS_KEY_SECRET"),
             ),
+            bucket_name=os.environ.get("OSS_BUCKET_NAME"),
         )
 
     def ensure_valid(self) -> None:
@@ -245,10 +250,14 @@ class OSSConfig(BaseModel):
             RuntimeError: If required AccessKey credentials are missing.
         """
         # Allow fallback to Alibaba Cloud AK/SK via from_env()
-        if not self.access_key_id or not self.access_key_secret:
+        if (
+            not self.access_key_id
+            or not self.access_key_secret
+            or not self.bucket_name
+        ):
             raise RuntimeError(
                 "Missing AccessKey for OSS. Set either OSS_ACCESS_KEY_ID/OSS_ACCESS_KEY_SECRET "
-                "or ALIBABA_CLOUD_ACCESS_KEY_ID/ALIBABA_CLOUD_ACCESS_KEY_SECRET.",
+                "or ALIBABA_CLOUD_ACCESS_KEY_ID/ALIBABA_CLOUD_ACCESS_KEY_SECRET or OSS_BUCKET_NAME.",
             )
 
 
@@ -278,6 +287,7 @@ class AgentRunDeployManager(DeployManager):
         oss_config: Optional[OSSConfig] = None,
         agentrun_config: Optional[AgentRunConfig] = None,
         build_root: Optional[Union[str, Path]] = None,
+        state_manager=None,
     ):
         """Initialize AgentRun deployment manager.
 
@@ -285,8 +295,9 @@ class AgentRunDeployManager(DeployManager):
             oss_config: OSS configuration for artifact storage. If None, loads from environment.
             agentrun_config: AgentRun service configuration. If None, loads from environment.
             build_root: Root directory for build artifacts. If None, uses parent directory of current working directory.
+            state_manager: Deployment state manager. If None, creates a new instance.
         """
-        super().__init__()
+        super().__init__(state_manager=state_manager)
         self.oss_config = oss_config or OSSConfig.from_env()
         self.agentrun_config = agentrun_config or AgentRunConfig.from_env()
         self.build_root = (
@@ -416,18 +427,19 @@ class AgentRunDeployManager(DeployManager):
             )
 
         name = deploy_name or default_deploy_name()
-        proj_root = project_dir.resolve()
+
+        # Generate build directory with platform-aware naming
+        # proj_root = project_dir.resolve()
         if isinstance(self.build_root, Path):
             effective_build_root = self.build_root.resolve()
         else:
             if self.build_root:
                 effective_build_root = Path(self.build_root).resolve()
             else:
-                effective_build_root = (
-                    proj_root.parent / ".agentscope_runtime_builds"
-                ).resolve()
+                # Use centralized directory generation function
+                effective_build_root = generate_build_directory("agentrun")
 
-        build_dir = effective_build_root / f"build-{int(time.time())}"
+        build_dir = effective_build_root
         build_dir.mkdir(parents=True, exist_ok=True)
 
         logger.info("Generating wrapper project: %s", name)
@@ -442,6 +454,7 @@ class AgentRunDeployManager(DeployManager):
         logger.info("Building wheel package from: %s", wrapper_project_dir)
         wheel_path = build_wheel(wrapper_project_dir)
         logger.info("Wheel package created: %s", wheel_path)
+
         return wheel_path, name
 
     def _generate_env_file(
@@ -560,9 +573,14 @@ class AgentRunDeployManager(DeployManager):
             FileNotFoundError: If specified files/directories don't exist.
         """
         if not agentrun_id:
-            if not runner and not project_dir and not external_whl_path:
+            if (
+                not app
+                and not runner
+                and not project_dir
+                and not external_whl_path
+            ):
                 raise ValueError(
-                    "Must provide either runner, project_dir, or external_whl_path",
+                    "Must provide either app, runner, project_dir, or external_whl_path",
                 )
         try:
             if runner or app:
@@ -579,6 +597,7 @@ class AgentRunDeployManager(DeployManager):
                     protocol_adapters=protocol_adapters,
                     requirements=requirements,
                     extra_packages=extra_packages,
+                    platform="agentrun",
                     **kwargs,
                 )
                 if project_dir:
@@ -647,7 +666,7 @@ class AgentRunDeployManager(DeployManager):
             logger.info("Uploading zip package to OSS")
             oss_result = await self._upload_to_fixed_oss_bucket(
                 zip_file_path=zip_file_path,
-                bucket_name="tmp-agentscope-agentrun-code",
+                bucket_name=self.oss_config.bucket_name,
             )
             logger.info("Zip package uploaded to OSS successfully")
 
@@ -661,21 +680,50 @@ class AgentRunDeployManager(DeployManager):
                 environment=environment,
             )
 
+            # Use base class UUID deploy_id (already set in __init__)
+            deploy_id = self.deploy_id
+            agent_runtime_id = agentrun_deploy_result["agent_runtime_id"]
+            endpoint_url = agentrun_deploy_result.get(
+                "agent_runtime_public_endpoint_url",
+                "",
+            )
+            console_url = (
+                f"https://functionai.console.aliyun.com/{self.agentrun_config.region_id}/"
+                f"agent/infra/agent-runtime/agent-detail?id={agent_runtime_id}"
+            )
+
+            # Save deployment to state manager
+            deployment = Deployment(
+                id=deploy_id,
+                platform="agentrun",
+                url=console_url,
+                status="running",
+                created_at=datetime.now().isoformat(),
+                agent_source=kwargs.get("agent_source"),
+                config={
+                    "agent_runtime_id": agent_runtime_id,
+                    "agent_runtime_endpoint_url": endpoint_url,
+                    "resource_name": name,
+                    "wheel_path": str(wheel_path),
+                    "artifact_url": oss_result.get("presigned_url", ""),
+                    "region_id": self.agentrun_config.region_id,
+                },
+            )
+            self.state_manager.save(deployment)
+
             # Return deployment results
             logger.info(
                 "Deployment completed successfully. Agent runtime ID: %s",
-                agentrun_deploy_result["agent_runtime_id"],
+                agent_runtime_id,
             )
             return {
                 "message": "Agent deployed successfully to AgentRun",
-                "agentrun_id": agentrun_deploy_result["agent_runtime_id"],
-                "agentrun_endpoint_url": agentrun_deploy_result[
-                    "agent_runtime_public_endpoint_url"
-                ],
+                "agentrun_id": agent_runtime_id,
+                "agentrun_endpoint_url": endpoint_url,
                 "wheel_path": str(wheel_path),
-                "artifact_url": oss_result["presigned_url"],
-                "url": f'https://functionai.console.aliyun.com/{self.agentrun_config.region_id}/agent/infra/agent-runtime/agent-detail?id={agentrun_deploy_result["agent_runtime_id"]}',
-                "deploy_id": agentrun_deploy_result["agent_runtime_id"],
+                "artifact_url": oss_result.get("presigned_url", ""),
+                "url": console_url,
+                "deploy_id": deploy_id,
                 "resource_name": name,
             }
 
@@ -861,7 +909,6 @@ ls -lh /output/{zip_filename}
             from alibabacloud_oss_v2.credentials import (
                 StaticCredentialsProvider,
             )
-            import datetime
         except ImportError as e:
             logger.error(
                 "OSS SDK not available. Install with: pip install alibabacloud-oss-v2",
@@ -2539,3 +2586,86 @@ ls -lh /output/{zip_filename}
                 "error": str(e),
                 "message": f"Exception occurred while publishing agent runtime version: {str(e)}",
             }
+
+    async def stop(self, deploy_id: str, **kwargs) -> Dict[str, Any]:
+        """Stop AgentRun deployment by deleting it.
+
+        Args:
+            deploy_id: AgentRun runtime ID (agent_runtime_id)
+            **kwargs: Additional parameters
+
+        Returns:
+            Dict with success status, message, and details
+        """
+        try:
+            # Try to get deployment info from state for context
+            deployment_info = None
+            deployment = None
+            try:
+                deployment = self.state_manager.get(deploy_id)
+                if deployment:
+                    deployment_info = {
+                        "url": deployment.url
+                        if hasattr(deployment, "url")
+                        else None,
+                        "resource_name": getattr(
+                            deployment,
+                            "resource_name",
+                            None,
+                        ),
+                    }
+                    logger.debug(
+                        f"Fetched deployment info from state: {deployment_info}",
+                    )
+            except Exception as e:
+                logger.debug(
+                    f"Could not fetch deployment info from state: {e}",
+                )
+
+            logger.info(f"Stopping AgentRun deployment: {deploy_id}")
+
+            # Get agent_runtime_id from deployment config
+            agent_runtime_id = None
+            if deployment and deployment.config:
+                agent_runtime_id = deployment.config.get("agent_runtime_id")
+
+            if not agent_runtime_id:
+                # Fallback: try using deploy_id as agent_runtime_id for backward compatibility
+                agent_runtime_id = deploy_id
+                logger.warning(
+                    f"Could not find agent_runtime_id in deployment config, "
+                    f"using deploy_id as fallback: {deploy_id}",
+                )
+
+            # Use the existing delete method with agent_runtime_id
+            result = await self.delete(agent_runtime_id)
+
+            if result.get("success"):
+                # Remove from state manager on successful deletion
+                try:
+                    self.state_manager.update_status(deploy_id, "stopped")
+                except KeyError:
+                    logger.debug(
+                        f"Deployment {deploy_id} not found in state (already removed)",
+                    )
+
+                return {
+                    "success": True,
+                    "message": f"AgentRun deployment {deploy_id} deleted successfully",
+                    "details": result,
+                }
+            else:
+                return {
+                    "success": False,
+                    "message": f"Failed to delete AgentRun deployment: {result.get('message', 'Unknown error')}",
+                    "details": result,
+                }
+        except Exception as e:
+            logger.error(
+                f"Failed to stop AgentRun deployment {deploy_id}: {e}",
+            )
+            return {
+                "success": False,
+                "message": f"Failed to stop AgentRun deployment: {e}",
+                "details": {"deploy_id": deploy_id, "error": str(e)},
+            }

agentscope_runtime/engine/deployers/base.py

@@ -1,18 +1,43 @@
 # -*- coding: utf-8 -*-
 import uuid
 from abc import abstractmethod, ABC
-from typing import Dict
+from typing import Dict, Any
 
 
 # there is not many attributes in it, consider it as interface, instead of
 # pydantic BaseModel
 class DeployManager(ABC):
-    def __init__(self):
+    def __init__(self, state_manager=None):
         self.deploy_id = str(uuid.uuid4())
         self._app = None
 
+        # Initialize state manager - shared across all deployers
+        if state_manager is None:
+            from agentscope_runtime.engine.deployers.state import (
+                DeploymentStateManager,
+            )
+
+            state_manager = DeploymentStateManager()
+        self.state_manager = state_manager
+
     @abstractmethod
     async def deploy(self, *args, **kwargs) -> Dict[str, str]:
         """Deploy the service and return a dictionary with deploy_id and
         URL."""
         raise NotImplementedError
+
+    @abstractmethod
+    async def stop(self, deploy_id: str, **kwargs) -> Dict[str, Any]:
+        """Stop the deployed service.
+
+        Args:
+            deploy_id: Deployment identifier
+            **kwargs: Platform-specific parameters (url, namespace, etc.)
+
+        Returns:
+            Dict with keys:
+                - success (bool): Whether stop succeeded
+                - message (str): Status message
+                - details (dict, optional): Platform-specific details
+        """
+        raise NotImplementedError

agentscope_runtime/engine/deployers/kubernetes_deployer.py

@@ -1,17 +1,19 @@
 # -*- coding: utf-8 -*-
 import logging
 import os
-import time
+from datetime import datetime
 from typing import Optional, Dict, List, Union, Any
 
 from pydantic import BaseModel, Field
 
+from agentscope_runtime.engine.deployers.state import Deployment
 from .adapter.protocol_adapter import ProtocolAdapter
 from .base import DeployManager
 from .utils.docker_image_utils import (
     ImageFactory,
     RegistryConfig,
 )
+from .utils.k8s_utils import isLocalK8sEnvironment
 from ...common.container_clients.kubernetes_client import (
     KubernetesClient,
 )
@@ -36,7 +38,7 @@ class K8sConfig(BaseModel):
 class BuildConfig(BaseModel):
     """Build configuration"""
 
-    build_context_dir: str = "/tmp/k8s_build"
+    build_context_dir: Optional[str] = None  # None allows caching
     dockerfile_template: str = None
     build_timeout: int = 600  # 10 minutes
     push_timeout: int = 300  # 5 minutes
@@ -51,15 +53,15 @@ class KubernetesDeployManager(DeployManager):
         kube_config: K8sConfig = None,
         registry_config: RegistryConfig = RegistryConfig(),
         use_deployment: bool = True,
-        build_context_dir: str = "/tmp/k8s_build",
+        build_context_dir: Optional[str] = None,
+        state_manager=None,
     ):
-        super().__init__()
+        super().__init__(state_manager=state_manager)
         self.kubeconfig = kube_config
         self.registry_config = registry_config
         self.image_factory = ImageFactory()
         self.use_deployment = use_deployment
         self.build_context_dir = build_context_dir
-        self._deployed_resources = {}
         self._built_images = {}
 
         self.k8s_client = KubernetesClient(
@@ -67,10 +69,65 @@ class KubernetesDeployManager(DeployManager):
             image_registry=self.registry_config.get_full_url(),
         )
 
+    @staticmethod
+    def get_service_endpoint(
+        service_external_ip: Optional[str],
+        service_port: Optional[Union[int, list]],
+        fallback_host: str = "127.0.0.1",
+    ) -> str:
+        """
+        Auto-select appropriate service endpoint based on detected environment.
+
+        Solves the common issue where Kubernetes LoadBalancer/ExternalIP is not
+        reachable from localhost in local clusters (e.g., Minikube/Kind).
+
+        Args:
+            service_external_ip: ExternalIP or LoadBalancer IP from Service
+            service_port: Target port
+            fallback_host: Host to use in local environments (default:
+            127.0.0.1)
+
+        Returns:
+            str: Full HTTP endpoint URL: http://<host>:<port>
+
+        Example:
+            >>> endpoint = get_service_endpoint('192.168.5.1', 8080)
+            >>> # In local env → 'http://127.0.0.1:8080'
+            >>> # In cloud env → 'http://192.168.5.1:8080'
+        """
+        if not service_external_ip:
+            service_external_ip = "127.0.0.1"
+
+        if not service_port:
+            service_port = 8080
+
+        if isinstance(service_port, list):
+            service_port = service_port[0]
+
+        if isLocalK8sEnvironment():
+            host = fallback_host
+            logger.info(
+                f"Local K8s environment detected; using {host} instead of "
+                f"{service_external_ip}",
+            )
+        else:
+            host = service_external_ip
+            logger.info(
+                f"Cloud/remote environment detected; using External IP: "
+                f"{host}",
+            )
+
+        return f"http://{host}:{service_port}"
+
+    @staticmethod
+    def get_resource_name(deploy_id: str) -> str:
+        return f"agent-{deploy_id[:8]}"
+
     async def deploy(
         self,
         app=None,
         runner=None,
+        entrypoint: Optional[str] = None,
         endpoint_path: str = "/process",
         stream: bool = True,
         custom_endpoints: Optional[List[Dict]] = None,
@@ -86,15 +143,20 @@ class KubernetesDeployManager(DeployManager):
         image_name: str = "agent_llm",
         image_tag: str = "latest",
         push_to_registry: bool = False,
+        use_cache: bool = True,
+        pypi_mirror: Optional[str] = None,
         **kwargs,
     ) -> Dict[str, Any]:
         """
         Deploy runner to Kubernetes.
 
+        All temporary files are created in cwd/.agentscope_runtime/ by default.
+
         Args:
             app: Agent app to be deployed
             runner: Complete Runner object with agent, environment_manager,
                 context_manager
+            entrypoint: Entrypoint spec (e.g., "app.py" or "app.py:handler")
             endpoint_path: API endpoint path
             stream: Enable streaming responses
             custom_endpoints: Custom endpoints from agent app
@@ -108,6 +170,8 @@ class KubernetesDeployManager(DeployManager):
             environment: Environment variables dict
             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
@@ -132,6 +196,7 @@ class KubernetesDeployManager(DeployManager):
                 built_image_name = self.image_factory.build_image(
                     app=app,
                     runner=runner,
+                    entrypoint=entrypoint,
                     requirements=requirements,
                     extra_packages=extra_packages or [],
                     base_image=base_image,
@@ -145,6 +210,8 @@ class KubernetesDeployManager(DeployManager):
                     port=port,
                     protocol_adapters=protocol_adapters,
                     custom_endpoints=custom_endpoints,
+                    use_cache=use_cache,
+                    pypi_mirror=pypi_mirror,
                     **kwargs,
                 )
                 if not built_image_name:
@@ -173,7 +240,7 @@ class KubernetesDeployManager(DeployManager):
             else:
                 volume_bindings = {}
 
-            resource_name = f"agent-{deploy_id[:8]}"
+            resource_name = self.get_resource_name(deploy_id)
 
             logger.info(f"Building kubernetes deployment for {deploy_id}")
 
@@ -197,33 +264,36 @@ class KubernetesDeployManager(DeployManager):
                 )
 
             if ports:
-                url = f"http://{ip}:{ports[0]}"
+                url = self.get_service_endpoint(ip, ports)
             else:
-                url = f"http://{ip}:8080"
+                url = self.get_service_endpoint(ip, port)
 
             logger.info(f"Deployment {deploy_id} successful: {url}")
 
-            self._deployed_resources[deploy_id] = {
-                "resource_name": resource_name,
-                "service_name": _id,
-                "image": built_image_name,
-                "created_at": time.time(),
-                "replicas": replicas if self.use_deployment else 1,
-                "config": {
-                    "runner": runner.__class__.__name__,
+            deployment = Deployment(
+                id=deploy_id,
+                platform="k8s",
+                url=url,
+                status="running",
+                created_at=datetime.now().isoformat(),
+                agent_source=kwargs.get("agent_source"),
+                config={
+                    "service_name": _id,
+                    "image": built_image_name,
+                    "replicas": replicas if self.use_deployment else 1,
+                    "runner": runner.__class__.__name__ if runner else None,
                     "extra_packages": extra_packages,
-                    "requirements": requirements,  # New format
+                    "requirements": requirements,
                     "base_image": base_image,
                     "port": port,
-                    "replicas": replicas,
                     "environment": environment,
                     "runtime_config": runtime_config,
                     "endpoint_path": endpoint_path,
                     "stream": stream,
-                    "protocol_adapters": protocol_adapters,
-                    **kwargs,
                 },
-            }
+            )
+            self.state_manager.save(deployment)
+
             return {
                 "deploy_id": deploy_id,
                 "url": url,
@@ -240,21 +310,81 @@ class KubernetesDeployManager(DeployManager):
                 f"Deployment failed: {e}, {traceback.format_exc()}",
             ) from e
 
-    async def stop(self) -> bool:
-        """Stop service"""
-        if self.deploy_id not in self._deployed_resources:
-            return False
+    async def stop(
+        self,
+        deploy_id: str,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Stop Kubernetes deployment.
+
+        Args:
+            deploy_id: Deployment identifier
+            **kwargs: Additional parameters
+
+        Returns:
+            Dict with success status, message, and details
+        """
+        # Derive resource name from deploy_id
+        resource_name = self.get_resource_name(deploy_id)
+
+        try:
+            # Try to remove the deployment
+            success = self.k8s_client.remove_deployment(resource_name)
+
+            if success:
+                # Remove from state manager
+                try:
+                    self.state_manager.update_status(deploy_id, "stopped")
+                except KeyError:
+                    logger.debug(
+                        f"Deployment {deploy_id} not found "
+                        f"in state (already removed)",
+                    )
 
-        resources = self._deployed_resources[self.deploy_id]
-        service_name = resources["service_name"]
-        return self.k8s_client.remove_deployment(service_name)
+                return {
+                    "success": True,
+                    "message": f"Kubernetes deployment {resource_name} "
+                    f"removed",
+                    "details": {
+                        "deploy_id": deploy_id,
+                        "resource_name": resource_name,
+                    },
+                }
+            else:
+                return {
+                    "success": False,
+                    "message": f"Kubernetes 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 K8s deployment {resource_name}: {e}",
+            )
+            return {
+                "success": False,
+                "message": f"Failed to remove K8s deployment: {e}",
+                "details": {
+                    "deploy_id": deploy_id,
+                    "resource_name": resource_name,
+                    "error": str(e),
+                },
+            }
 
     def get_status(self) -> str:
         """Get deployment status"""
-        if self.deploy_id not in self._deployed_resources:
+        deployment = self.state_manager.get(self.deploy_id)
+        if not deployment:
             return "not_found"
 
-        resources = self._deployed_resources[self.deploy_id]
-        service_name = resources["service_name"]
+        # Get service_name from config
+        config = getattr(deployment, "config", {})
+        service_name = config.get("service_name")
+        if not service_name:
+            return "unknown"
 
         return self.k8s_client.get_deployment_status(service_name)