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

agentscope_runtime/engine/deployers/local_deployer.py

@@ -1,15 +1,17 @@
 # -*- coding: utf-8 -*-
-# pylint:disable=protected-access, unused-argument
+# pylint:disable=protected-access, unused-argument, too-many-branches
 
 import asyncio
 import logging
 import os
 import socket
 import threading
+from datetime import datetime
 from typing import Callable, Optional, Type, Any, Dict, Union, List
 
 import uvicorn
 
+from agentscope_runtime.engine.deployers.state import Deployment
 from .adapter.protocol_adapter import ProtocolAdapter
 from .base import DeployManager
 from .utils.deployment_modes import DeploymentMode
@@ -29,7 +31,7 @@ class LocalDeployManager(DeployManager):
     def __init__(
         self,
         host: str = "127.0.0.1",
-        port: int = 8000,
+        port: int = 8090,
         shutdown_timeout: int = 30,
         startup_timeout: int = 30,
         logger: Optional[logging.Logger] = None,
@@ -80,6 +82,9 @@ class LocalDeployManager(DeployManager):
         broker_url: Optional[str] = None,
         backend_url: Optional[str] = None,
         enable_embedded_worker: bool = False,
+        # New parameters for project-based deployment
+        project_dir: Optional[str] = None,
+        entrypoint: Optional[str] = None,
         **kwargs: Any,
     ) -> Dict[str, str]:
         """Deploy using unified FastAPI architecture.
@@ -100,6 +105,8 @@ class LocalDeployManager(DeployManager):
             backend_url: Celery backend URL for result storage
             enable_embedded_worker: Whether to run Celery worker
                 embedded in the app
+            project_dir: Project directory (for DETACHED_PROCESS mode)
+            entrypoint: Entrypoint specification (for DETACHED_PROCESS mode)
             **kwargs: Additional keyword arguments
 
         Returns:
@@ -152,6 +159,8 @@ class LocalDeployManager(DeployManager):
                     after_finish=after_finish,
                     custom_endpoints=custom_endpoints,
                     protocol_adapters=protocol_adapters,
+                    project_dir=project_dir,
+                    entrypoint=entrypoint,
                     **kwargs,
                 )
             else:
@@ -171,6 +180,7 @@ class LocalDeployManager(DeployManager):
         broker_url: Optional[str] = None,
         backend_url: Optional[str] = None,
         enable_embedded_worker: bool = False,
+        agent_source: Optional[str] = None,
         **kwargs,
     ) -> Dict[str, str]:
         """Deploy in daemon thread mode."""
@@ -208,21 +218,43 @@ class LocalDeployManager(DeployManager):
         await self._wait_for_server_ready(self._startup_timeout)
 
         self.is_running = True
-        self.deploy_id = f"daemon_{self.host}_{self.port}"
+
+        url = f"http://{self.host}:{self.port}"
 
         self._logger.info(
-            f"FastAPI service started at http://{self.host}:{self.port}",
+            f"FastAPI service started at {url}",
+        )
+
+        deployment = Deployment(
+            id=self.deploy_id,
+            platform="local",
+            url=url,
+            status="running",
+            created_at=datetime.now().isoformat(),
+            agent_source=agent_source,
+            config={
+                "mode": DeploymentMode.DAEMON_THREAD,
+                "host": self.host,
+                "port": self.port,
+                "broker_url": broker_url,
+                "backend_url": backend_url,
+                "enable_embedded_worker": enable_embedded_worker,
+            },
         )
+        self.state_manager.save(deployment)
 
         return {
             "deploy_id": self.deploy_id,
-            "url": f"http://{self.host}:{self.port}",
+            "url": url,
         }
 
     async def _deploy_detached_process(
         self,
         runner: Optional[Any] = None,
         protocol_adapters: Optional[list[ProtocolAdapter]] = None,
+        project_dir: Optional[str] = None,
+        entrypoint: Optional[str] = None,
+        agent_source: Optional[str] = None,
         **kwargs,
     ) -> Dict[str, str]:
         """Deploy in detached process mode."""
@@ -230,9 +262,14 @@ class LocalDeployManager(DeployManager):
             "Deploying FastAPI service in detached process mode...",
         )
 
-        if runner is None and self._app is None:
+        # Clean up old log files (older than 24 hours)
+        ProcessManager.cleanup_old_logs(max_age_hours=24)
+
+        # Original behavior: require app or runner or entrypoint
+        if runner is None and self._app is None and entrypoint is None:
             raise ValueError(
-                "Detached process mode requires an app or runner",
+                "Detached process mode requires an app, runner, "
+                "project_dir, or entrypoint",
             )
 
         if "agent" in kwargs:
@@ -245,18 +282,29 @@ class LocalDeployManager(DeployManager):
             app=self._app,
             runner=runner,
             protocol_adapters=protocol_adapters,
+            entrypoint=entrypoint,
             **kwargs,
         )
 
+        if not project_dir:
+            raise RuntimeError("Failed to parse project directory")
+
         try:
             entry_script = get_bundle_entry_script(project_dir)
             script_path = os.path.join(project_dir, entry_script)
-
+            env = kwargs.get("environment", {}) or {}
+            env.update(
+                {
+                    "HOST": self.host,
+                    "PORT": str(self.port),
+                },
+            )
             # Start detached process using the packaged project
             pid = await self.process_manager.start_detached_process(
                 script_path=script_path,
                 host=self.host,
                 port=self.port,
+                env=env,
             )
 
             self._detached_process_pid = pid
@@ -273,35 +321,65 @@ class LocalDeployManager(DeployManager):
             )
 
             if not service_ready:
-                raise RuntimeError("Service did not start within timeout")
+                # Check if process is still running
+                is_running = self.process_manager.is_process_running(pid)
+
+                # Get process logs
+                logs = self.process_manager.get_process_logs(max_lines=50)
+
+                # Log the detailed error for debugging
+                self._logger.error(
+                    f"Service did not start within timeout. "
+                    f"Process (PID: {pid}) status: "
+                    f"{'running' if is_running else 'terminated'}. "
+                    f"Host: {self.host}, Port: {self.port}.\n\n"
+                    f"Process logs:\n{logs}",
+                )
+
+                # Raise a simple error message
+                raise RuntimeError(
+                    "Service failed to start. Check logs above for details.",
+                )
 
             self.is_running = True
-            self.deploy_id = f"detached_{pid}"
+
+            url = f"http://{self.host}:{self.port}"
 
             self._logger.info(
                 f"FastAPI service started in detached process (PID: {pid})",
             )
 
+            deployment = Deployment(
+                id=self.deploy_id,
+                platform="local",
+                url=url,
+                status="running",
+                created_at=datetime.now().isoformat(),
+                agent_source=agent_source,
+                config={
+                    "mode": DeploymentMode.DETACHED_PROCESS,
+                    "host": self.host,
+                    "port": self.port,
+                    "pid": pid,
+                    "pid_file": self._detached_pid_file,
+                    "project_dir": project_dir,
+                },
+            )
+            self.state_manager.save(deployment)
+
             return {
                 "deploy_id": self.deploy_id,
-                "url": f"http://{self.host}:{self.port}",
+                "url": url,
             }
 
         except Exception as e:
-            # Cleanup on failure
-            if os.path.exists(project_dir):
-                try:
-                    import shutil
-
-                    shutil.rmtree(project_dir)
-                except OSError:
-                    pass
             raise e
 
     @staticmethod
     async def create_detached_project(
         app=None,
         runner: Optional[Any] = None,
+        entrypoint: Optional[str] = None,
         endpoint_path: str = "/process",
         requirements: Optional[Union[str, List[str]]] = None,
         extra_packages: Optional[List[str]] = None,
@@ -310,6 +388,7 @@ class LocalDeployManager(DeployManager):
         broker_url: Optional[str] = None,
         backend_url: Optional[str] = None,
         enable_embedded_worker: bool = False,
+        platform: str = "local",
         **kwargs,
     ) -> str:
         project_dir, _ = build_detached_app(
@@ -317,18 +396,81 @@ class LocalDeployManager(DeployManager):
             runner=runner,
             requirements=requirements,
             extra_packages=extra_packages,
+            platform=platform,
+            entrypoint=entrypoint,
             **kwargs,
         )
 
         return project_dir
 
-    async def stop(self) -> None:
-        """Stop the FastAPI service (unified method for all modes)."""
-        if not self.is_running:
-            self._logger.warning("Service is not running")
-            return
+    async def stop(
+        self,
+        deploy_id: str,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Stop the FastAPI service.
+
+        Args:
+            deploy_id: Deployment identifier
+            **kwargs: Additional parameters
 
+        Returns:
+            Dict with success status, message, and details
+        """
+        # If URL not provided, try to get it from state manager
         try:
+            deployment = self.state_manager.get(deploy_id)
+            if deployment:
+                url = deployment.url
+                self._logger.debug(f"Fetched URL from state: {url}")
+        except Exception as e:
+            self._logger.debug(f"Could not fetch URL from state: {e}")
+
+        if not deployment:
+            return {
+                "success": False,
+                "message": "Deploy id not found",
+                "details": {
+                    "deploy_id": deploy_id,
+                    "error": "Deploy id not found",
+                },
+            }
+
+        # Only attempt HTTP shutdown for detached process mode
+        # In daemon thread mode, HTTP shutdown would kill the entire process
+        # (including pytest), so we skip it and use direct stop methods instead
+        if (
+            url
+            and deployment.config["mode"] == DeploymentMode.DETACHED_PROCESS
+        ):
+            try:
+                import requests
+
+                response = requests.post(f"{url}/shutdown", timeout=5)
+                if response.status_code == 200:
+                    # Remove from state manager on successful shutdown
+                    try:
+                        self.state_manager.update_status(deploy_id, "stopped")
+                    except KeyError:
+                        self._logger.debug(
+                            f"Deployment {deploy_id} not found "
+                            f"in state (already removed)",
+                        )
+                    self.is_running = False
+                    return {
+                        "success": True,
+                        "message": "Shutdown signal sent to detached process",
+                        "details": {"url": url, "deploy_id": deploy_id},
+                    }
+
+            except requests.exceptions.RequestException as e:
+                # If HTTP shutdown fails, continue with direct stop methods
+                self._logger.debug(
+                    f"HTTP shutdown failed, falling back to direct stop: {e}",
+                )
+
+        try:
+            # when run in from main process instead of cli, make sure close
             if self._detached_process_pid:
                 # Detached process mode
                 await self._stop_detached_process()
@@ -336,9 +478,27 @@ class LocalDeployManager(DeployManager):
                 # Daemon thread mode
                 await self._stop_daemon_thread()
 
+            # Remove from state manager on successful stop
+            try:
+                self.state_manager.update_status(deploy_id, "stopped")
+            except KeyError:
+                self._logger.debug(
+                    f"Deployment {deploy_id} not found in state (already "
+                    f"removed)",
+                )
+
+            return {
+                "success": True,
+                "message": "Service stopped successfully",
+                "details": {"deploy_id": deploy_id},
+            }
         except Exception as e:
             self._logger.error(f"Failed to stop service: {e}")
-            raise RuntimeError(f"Failed to stop FastAPI service: {e}") from e
+            return {
+                "success": False,
+                "message": f"Failed to stop service: {e}",
+                "details": {"deploy_id": deploy_id, "error": str(e)},
+            }
 
     async def _stop_daemon_thread(self):
         """Stop daemon thread mode service."""
@@ -387,6 +547,9 @@ class LocalDeployManager(DeployManager):
         if self._detached_pid_file:
             self.process_manager.cleanup_pid_file(self._detached_pid_file)
 
+        # Cleanup log file (keep file for debugging)
+        self.process_manager.cleanup_log_file(keep_file=True)
+
         # Reset state
         self._detached_process_pid = None
         self._detached_pid_file = None

agentscope_runtime/engine/deployers/modelstudio_deployer.py

@@ -7,9 +7,9 @@
 import json
 import logging
 import os
-import time
+from datetime import datetime
 from pathlib import Path
-from typing import Dict, Optional, List, Union, Tuple
+from typing import Dict, Optional, List, Union, Tuple, Any
 
 import requests
 from pydantic import BaseModel, Field
@@ -17,11 +17,14 @@ 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 (
     generate_wrapper_project,
     build_wheel,
     default_deploy_name,
+    get_user_bundle_appdir,
 )
 
 logger = logging.getLogger(__name__)
@@ -538,8 +541,9 @@ class ModelstudioDeployManager(DeployManager):
         oss_config: Optional[OSSConfig] = None,
         modelstudio_config: Optional[ModelstudioConfig] = None,
         build_root: Optional[Union[str, Path]] = None,
+        state_manager=None,
     ) -> None:
-        super().__init__()
+        super().__init__(state_manager=state_manager)
         self.oss_config = oss_config or OSSConfig.from_env()
         self.modelstudio_config = (
             modelstudio_config or ModelstudioConfig.from_env()
@@ -552,11 +556,11 @@ class ModelstudioDeployManager(DeployManager):
         cmd: Optional[str] = None,
         deploy_name: Optional[str] = None,
         telemetry_enabled: bool = True,
+        environment: Optional[Dict[str, str]] = None,
+        requirements: Optional[Union[str, List[str]]] = None,
     ) -> Tuple[Path, str]:
         """
-        校验参数、生成 wrapper 项目并构建 wheel。
-
-        返回: (wheel_path, wrapper_project_dir, name)
+        generate temp project path and build wheel.
         """
         if not project_dir or not cmd:
             raise ValueError(
@@ -569,18 +573,18 @@ class ModelstudioDeployManager(DeployManager):
             raise FileNotFoundError(f"Project dir not found: {project_dir}")
 
         name = deploy_name or default_deploy_name()
-        proj_root = project_dir.resolve()
+
+        # Generate build directory with platform-aware naming
         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("modelstudio")
 
-        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 for %s", name)
@@ -590,10 +594,15 @@ class ModelstudioDeployManager(DeployManager):
             start_cmd=cmd,
             deploy_name=name,
             telemetry_enabled=telemetry_enabled,
+            requirements=requirements,
         )
 
+        # pass environments to the project from user setting
+        user_bundle_app_dir = get_user_bundle_appdir(build_dir, project_dir)
+        self._generate_env_file(user_bundle_app_dir, environment)
         logger.info("Building wheel under %s", wrapper_project_dir)
         wheel_path = build_wheel(wrapper_project_dir)
+
         return wheel_path, name
 
     def _generate_env_file(
@@ -616,7 +625,9 @@ class ModelstudioDeployManager(DeployManager):
             variables provided
         """
         if not environment:
-            return None
+            environment = {}
+        environment["HOST"] = os.environ.get("HOST", "0.0.0.0")
+        environment["PORT"] = int(os.environ.get("PORT", "8080"))
 
         project_path = Path(project_dir).resolve()
         if not project_path.exists():
@@ -731,14 +742,19 @@ class ModelstudioDeployManager(DeployManager):
         resource_name (deploy_name), and workspace_id.
         """
         if not agent_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(
-                    "Either runner, project_dir, "
+                    "Either app, runner, project_dir, "
                     "or external_whl_path must be provided.",
                 )
 
         try:
-            if runner:
+            if runner or app:
                 if "agent" in kwargs:
                     kwargs.pop("agent")
 
@@ -751,6 +767,7 @@ class ModelstudioDeployManager(DeployManager):
                     requirements=requirements,
                     extra_packages=extra_packages,
                     port=8080,
+                    platform="modelstudio",
                     **kwargs,
                 )
                 if project_dir:
@@ -793,6 +810,8 @@ class ModelstudioDeployManager(DeployManager):
                     cmd=cmd,
                     deploy_name=deploy_name,
                     telemetry_enabled=telemetry_enabled,
+                    environment=environment,
+                    requirements=requirements,
                 )
 
             console_url = ""
@@ -814,16 +833,41 @@ class ModelstudioDeployManager(DeployManager):
                     telemetry_enabled,
                 )
 
+            # Use base class UUID deploy_id (already set in __init__)
+            deploy_id = self.deploy_id
+
+            # Save deployment to state manager
+            if deploy_identifier:
+                deployment = Deployment(
+                    id=deploy_id,
+                    platform="modelstudio",
+                    url=console_url,
+                    status="running",
+                    created_at=datetime.now().isoformat(),
+                    agent_source=kwargs.get("agent_source"),
+                    config={
+                        "modelstudio_deploy_id": deploy_identifier,
+                        "resource_name": name,
+                        "workspace_id": os.environ.get(
+                            "MODELSTUDIO_WORKSPACE_ID",
+                            "",
+                        ).strip(),
+                        "wheel_path": str(wheel_path),
+                    },
+                )
+                self.state_manager.save(deployment)
+
             result: Dict[str, str] = {
                 "wheel_path": str(wheel_path),
                 "resource_name": name,
                 "url": console_url,
+                "deploy_id": deploy_id,
             }
             env_ws = os.environ.get("MODELSTUDIO_WORKSPACE_ID")
             if env_ws and env_ws.strip():
                 result["workspace_id"] = env_ws.strip()
             if deploy_identifier:
-                result["deploy_id"] = deploy_identifier
+                result["modelstudio_deploy_id"] = deploy_identifier
 
             return result
         except Exception as e:
@@ -835,8 +879,55 @@ class ModelstudioDeployManager(DeployManager):
             )
             raise
 
-    async def stop(self) -> None:  # pragma: no cover - not supported yet
-        pass
+    async def stop(self, deploy_id: str, **kwargs) -> Dict[str, Any]:
+        """Stop ModelStudio deployment.
+
+        Note: ModelStudio stop API not yet available.
+
+        Args:
+            deploy_id: Deployment identifier
+            **kwargs: Additional parameters
+
+        Returns:
+            Dict with success status and message
+        """
+        # Try to get deployment info from state for context
+        deployment_info = None
+        try:
+            deployment = self.state_manager.get(deploy_id)
+            if deployment:
+                deployment_info = {
+                    "url": deployment.url
+                    if hasattr(deployment, "url")
+                    else None,
+                    "workspace_id": getattr(deployment, "workspace_id", 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}")
+
+        # TODO: Implement when ModelStudio provides stop/delete API
+        # When API is available, call it here and then remove from state:
+        # self.state_manager.remove(deploy_id)
+
+        logger.warning(
+            f"ModelStudio stop not implemented for deploy_id={deploy_id} - API not yet available",
+        )
+
+        details = {
+            "deploy_id": deploy_id,
+            "note": "Manual cleanup required via ModelStudio console",
+        }
+        if deployment_info:
+            details.update(deployment_info)
+
+        return {
+            "success": False,
+            "message": "ModelStudio stop not implemented - API not yet available",
+            "details": details,
+        }
 
     def get_status(self) -> str:  # pragma: no cover - not supported yet
         return "unknown"

agentscope_runtime/engine/deployers/state/__init__.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+"""Deployment state management."""
+
+from agentscope_runtime.engine.deployers.state.manager import (
+    DeploymentStateManager,
+)
+from agentscope_runtime.engine.deployers.state.schema import Deployment
+
+__all__ = ["DeploymentStateManager", "Deployment"]