agentscope-runtime 0.1.5b1__py3-none-any.whl → 0.1.6__py3-none-any.whl

agentscope_runtime/engine/deployers/local_deployer.py

@@ -1,385 +1,525 @@
 # -*- coding: utf-8 -*-
-# pylint:disable=protected-access
-
 import asyncio
+import json
 import logging
-import os
 import socket
 import threading
-from typing import Callable, Optional, Type, Any, Dict, Union, List
+import time
+import uuid
+from contextlib import asynccontextmanager
+from typing import Optional, Dict, Any, Callable, Type, Tuple, Union
 
 import uvicorn
+from fastapi import FastAPI, HTTPException, Request, Response
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
 
-from .adapter.protocol_adapter import ProtocolAdapter
 from .base import DeployManager
-from .utils.deployment_modes import DeploymentMode
-from .utils.package_project_utils import package_project, PackageConfig
-from .utils.service_utils import (
-    FastAPIAppFactory,
-    FastAPITemplateManager,
-    ProcessManager,
-    ServicesConfig,
-)
+from .adapter.protocol_adapter import ProtocolAdapter
+from ..schemas.agent_schemas import AgentRequest, AgentResponse, Error
 
 
 class LocalDeployManager(DeployManager):
-    """Unified LocalDeployManager supporting multiple deployment modes."""
-
-    def __init__(
-        self,
-        host: str = "127.0.0.1",
-        port: int = 8000,
-        shutdown_timeout: int = 120,
-        logger: Optional[logging.Logger] = None,
-    ):
-        """Initialize LocalDeployManager.
-
-        Args:
-            host: Host to bind to
-            port: Port to bind to
-            shutdown_timeout: Timeout for graceful shutdown
-            logger: Logger instance
-        """
+    def __init__(self, host: str = "localhost", port: int = 8090):
         super().__init__()
         self.host = host
         self.port = port
-        self._shutdown_timeout = shutdown_timeout
-        self._logger = logger or logging.getLogger(__name__)
-
-        # State management
-        self.is_running = False
-
-        # Daemon thread mode attributes
-        self._server: Optional[uvicorn.Server] = None
-        self._server_thread: Optional[threading.Thread] = None
-        self._server_task: Optional[asyncio.Task] = None
-
-        # Detached process mode attributes
-        self._detached_process_pid: Optional[int] = None
-        self._detached_pid_file: Optional[str] = None
-        self.process_manager = ProcessManager(
-            shutdown_timeout=shutdown_timeout,
+        self._server = None
+        self._server_task = None
+        self._server_thread = None  # Add thread for server
+        self._is_running = False
+        self._logger = logging.getLogger(__name__)
+        self._app = None
+        self._startup_timeout = 30  # seconds
+        self._shutdown_timeout = 10  # seconds
+        self._setup_logging()
+
+    def _setup_logging(self):
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
         )
 
-        # Template manager
-        self.template_manager = FastAPITemplateManager()
+        app_logger = logging.getLogger("app")
+        app_logger.setLevel(logging.INFO)
 
-    async def deploy(
+        file_handler = logging.handlers.RotatingFileHandler(
+            "app.log",
+            maxBytes=10 * 1024 * 1024,  # 10MB
+            backupCount=5,
+        )
+        file_handler.setFormatter(formatter)
+        app_logger.addHandler(file_handler)
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(formatter)
+        app_logger.addHandler(console_handler)
+
+        access_logger = logging.getLogger("access")
+        access_logger.setLevel(logging.INFO)
+        access_file_handler = logging.handlers.RotatingFileHandler(
+            "access.log",
+            maxBytes=10 * 1024 * 1024,
+            backupCount=5,
+        )
+        access_file_handler.setFormatter(
+            logging.Formatter("%(asctime)s - %(message)s"),
+        )
+        access_logger.addHandler(access_file_handler)
+
+        self.app_logger = app_logger
+        self.access_logger = access_logger
+
+    def _create_fastapi_app(self) -> FastAPI:
+        """Create and configure FastAPI application with lifespan
+        management."""
+
+        @asynccontextmanager
+        async def lifespan(app: FastAPI) -> Any:
+            """Manage the application lifespan."""
+            if hasattr(self, "before_start") and self.before_start:
+                if asyncio.iscoroutinefunction(self.before_start):
+                    await self.before_start(app, **getattr(self, "kwargs", {}))
+                else:
+                    self.before_start(app, **getattr(self, "kwargs", {}))
+            yield
+            if hasattr(self, "after_finish") and self.after_finish:
+                if asyncio.iscoroutinefunction(self.after_finish):
+                    await self.after_finish(app, **getattr(self, "kwargs", {}))
+                else:
+                    self.after_finish(app, **getattr(self, "kwargs", {}))
+
+        app = FastAPI(
+            title="Agent Service",
+            version="1.0.0",
+            description="Production-ready Agent Service API",
+            lifespan=lifespan,
+        )
+
+        self._add_middleware(app)
+        self._add_health_endpoints(app)
+
+        if hasattr(self, "func") and self.func:
+            self._add_main_endpoint(app)
+
+        return app
+
+    def _add_middleware(self, app: FastAPI) -> None:
+        """Add middleware to the FastAPI application."""
+
+        @app.middleware("http")
+        async def log_requests(request: Request, call_next):
+            start_time = time.time()
+
+            self.app_logger.info(f"Request: {request.method} {request.url}")
+            response = await call_next(
+                request,
+            )
+            process_time = time.time() - start_time
+            self.access_logger.info(
+                f'{request.client.host} - "{request.method} {request.url}" '
+                f"{response.status_code} - {process_time:.3f}s",
+            )
+
+            return response
+
+        @app.middleware("http")
+        async def custom_middleware(
+            request: Request,
+            call_next: Callable,
+        ) -> Response:
+            """Custom middleware for request processing."""
+            response: Response = await call_next(request)
+            return response
+
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=["*"],
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+
+    def _add_health_endpoints(self, app: FastAPI) -> None:
+        """Add health check endpoints to the FastAPI application."""
+
+        @app.get("/health")
+        async def health_check():
+            return {
+                "status": "healthy",
+                "timestamp": time.time(),
+                "service": "agent-service",
+            }
+
+        @app.get("/readiness")
+        async def readiness() -> str:
+            """Check if the application is ready to serve requests."""
+            if getattr(app.state, "is_ready", True):
+                return "success"
+            raise HTTPException(
+                status_code=500,
+                detail="Application is not ready",
+            )
+
+        @app.get("/liveness")
+        async def liveness() -> str:
+            """Check if the application is alive and healthy."""
+            if getattr(app.state, "is_healthy", True):
+                return "success"
+            raise HTTPException(
+                status_code=500,
+                detail="Application is not healthy",
+            )
+
+        @app.get("/")
+        async def root():
+            return {"message": "Agent Service is running"}
+
+    def _add_main_endpoint(self, app: FastAPI) -> None:
+        """Add the main processing endpoint to the FastAPI application."""
+
+        async def _get_request_info(request: Request) -> Tuple[Dict, Any, str]:
+            """Extract request information from the HTTP request."""
+            body = await request.body()
+            request_body = json.loads(body.decode("utf-8")) if body else {}
+
+            user_id = request_body.get("user_id", "")
+
+            if hasattr(self, "request_model") and self.request_model:
+                try:
+                    request_body_obj = self.request_model.model_validate(
+                        request_body,
+                    )
+                except Exception as e:
+                    raise HTTPException(
+                        status_code=400,
+                        detail=f"Invalid request format: {e}",
+                    ) from e
+            else:
+                request_body_obj = request_body
+
+            query_params = dict(request.query_params)
+            return query_params, request_body_obj, user_id
+
+        def _get_request_id(request_body_obj: Any) -> str:
+            """Extract or generate a request ID from the request body."""
+            if hasattr(request_body_obj, "header") and hasattr(
+                request_body_obj.header,
+                "request_id",
+            ):
+                request_id = request_body_obj.header.request_id
+            elif (
+                isinstance(
+                    request_body_obj,
+                    dict,
+                )
+                and "request_id" in request_body_obj
+            ):
+                request_id = request_body_obj["request_id"]
+            else:
+                request_id = str(uuid.uuid4())
+            return request_id
+
+        @app.post(self.endpoint_path)
+        async def main_endpoint(request: Request):
+            """Main endpoint handler for processing requests."""
+            try:
+                (
+                    _,  # query_params
+                    request_body_obj,
+                    user_id,
+                ) = await _get_request_info(
+                    request=request,
+                )
+                request_id = _get_request_id(request_body_obj)
+                if (
+                    hasattr(
+                        self,
+                        "response_type",
+                    )
+                    and self.response_type == "sse"
+                ):
+                    return self._handle_sse_response(
+                        user_id=user_id,
+                        request_body_obj=request_body_obj,
+                        request_id=request_id,
+                    )
+                else:
+                    return await self._handle_standard_response(
+                        user_id=user_id,
+                        request_body_obj=request_body_obj,
+                        request_id=request_id,
+                    )
+
+            except Exception as e:
+                self._logger.error(f"Request processing failed: {e}")
+                raise HTTPException(status_code=500, detail=str(e)) from e
+
+    def _handle_sse_response(
+        self,
+        user_id: str,
+        request_body_obj: Any,
+        request_id: str,
+    ) -> StreamingResponse:
+        """Handle Server-Sent Events response."""
+
+        async def stream_generator():
+            """Generate streaming response data."""
+            try:
+                if asyncio.iscoroutinefunction(self.func):
+                    async for output in self.func(
+                        user_id=user_id,
+                        request=request_body_obj,
+                        request_id=request_id,
+                    ):
+                        _data = self._create_success_result(
+                            output=output,
+                        )
+                        yield f"data: {_data}\n\n"
+                else:
+                    # For sync functions, we need to handle differently
+                    result = self.func(
+                        user_id=user_id,
+                        request=request_body_obj,
+                        request_id=request_id,
+                    )
+                    if hasattr(result, "__aiter__"):
+                        async for output in result:
+                            _data = self._create_success_result(
+                                output=output,
+                            )
+                            yield f"data: {_data}\n\n"
+                    else:
+                        _data = self._create_success_result(
+                            output=result,
+                        )
+                        yield f"data: {_data}\n\n"
+            except Exception as e:
+                _data = self._create_error_response(
+                    request_id=request_id,
+                    error=e,
+                )
+                yield f"data: {_data}\n\n"
+
+        return StreamingResponse(
+            stream_generator(),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+            },
+        )
+
+    async def _handle_standard_response(
         self,
-        runner: Optional[Any] = None,
+        user_id: str,
+        request_body_obj: Any,
+        request_id: str,
+    ):
+        """Handle standard JSON response."""
+        try:
+            if asyncio.iscoroutinefunction(self.func):
+                result = await self.func(
+                    user_id=user_id,
+                    request=request_body_obj,
+                    request_id=request_id,
+                )
+            else:
+                result = self.func(
+                    user_id=user_id,
+                    request=request_body_obj,
+                    request_id=request_id,
+                )
+
+            return self._create_success_result(
+                output=result,
+            )
+        except Exception as e:
+            return self._create_error_response(request_id=request_id, error=e)
+
+    def _create_success_result(
+        self,
+        output: Union[BaseModel, Dict, str],
+    ) -> str:
+        """Create a success response."""
+        if isinstance(output, BaseModel):
+            return output.model_dump_json()
+        elif isinstance(output, dict):
+            return json.dumps(output)
+        else:
+            return output
+
+    def _create_error_response(
+        self,
+        request_id: str,
+        error: Exception,
+    ) -> str:
+        """Create an error response."""
+        response = AgentResponse(id=request_id)
+        response.failed(Error(code=str(error), message=str(error)))
+        return response.model_dump_json()
+
+    def deploy_sync(
+        self,
+        func: Callable,
         endpoint_path: str = "/process",
-        request_model: Optional[Type] = None,
+        request_model: Optional[Type] = AgentRequest,
         response_type: str = "sse",
-        stream: bool = True,
         before_start: Optional[Callable] = None,
         after_finish: Optional[Callable] = None,
-        mode: DeploymentMode = DeploymentMode.DAEMON_THREAD,
-        services_config: Optional[ServicesConfig] = None,
-        protocol_adapters: Optional[list[ProtocolAdapter]] = None,
         **kwargs: Any,
     ) -> Dict[str, str]:
-        """Deploy using unified FastAPI architecture.
+        """
+        Deploy the agent as a FastAPI service (synchronous version).
 
         Args:
-            runner: Runner instance (for DAEMON_THREAD mode)
-            endpoint_path: API endpoint path
+            func: Custom processing function
+            endpoint_path: API endpoint path for the processing function
             request_model: Pydantic model for request validation
             response_type: Response type - "json", "sse", or "text"
-            stream: Enable streaming responses
             before_start: Callback function called before server starts
             after_finish: Callback function called after server finishes
-            mode: Deployment mode
-            services_config: Services configuration
-            protocol_adapters: Protocol adapters
-            **kwargs: Additional keyword arguments
+            **kwargs: Additional keyword arguments passed to callbacks
 
         Returns:
-            Dict containing deploy_id and url
+            Dict[str, str]: Dictionary containing deploy_id and url of the
+            deployed service
 
         Raises:
             RuntimeError: If deployment fails
         """
-        if self.is_running:
-            raise RuntimeError("Service is already running")
-
-        try:
-            if mode == DeploymentMode.DAEMON_THREAD:
-                return await self._deploy_daemon_thread(
-                    runner=runner,
-                    endpoint_path=endpoint_path,
-                    request_model=request_model,
-                    response_type=response_type,
-                    stream=stream,
-                    before_start=before_start,
-                    after_finish=after_finish,
-                    services_config=services_config,
-                    protocol_adapters=protocol_adapters,
-                    **kwargs,
-                )
-            elif mode == DeploymentMode.DETACHED_PROCESS:
-                return await self._deploy_detached_process(
-                    runner=runner,
-                    endpoint_path=endpoint_path,
-                    request_model=request_model,
-                    response_type=response_type,
-                    stream=stream,
-                    before_start=before_start,
-                    after_finish=after_finish,
-                    services_config=services_config,
-                    protocol_adapters=protocol_adapters,
-                    **kwargs,
-                )
-            else:
-                raise ValueError(
-                    f"Unsupported deployment mode for LocalDeployManager: "
-                    f"{mode}",
-                )
-
-        except Exception as e:
-            self._logger.error(f"Deployment failed: {e}")
-            raise RuntimeError(f"Failed to deploy service: {e}") from e
+        return asyncio.run(
+            self._deploy_async(
+                func=func,
+                endpoint_path=endpoint_path,
+                request_model=request_model,
+                response_type=response_type,
+                before_start=before_start,
+                after_finish=after_finish,
+                **kwargs,
+            ),
+        )
 
-    async def _deploy_daemon_thread(
+    async def deploy(
         self,
-        runner: Optional[Any] = None,
+        func: Callable,
+        endpoint_path: str = "/process",
+        request_model: Optional[Type] = AgentRequest,
+        response_type: str = "sse",
+        before_start: Optional[Callable] = None,
+        after_finish: Optional[Callable] = None,
         protocol_adapters: Optional[list[ProtocolAdapter]] = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> Dict[str, str]:
-        """Deploy in daemon thread mode."""
-        self._logger.info("Deploying FastAPI service in daemon thread mode...")
-
-        # Create FastAPI app using factory
-        app = FastAPIAppFactory.create_app(
-            runner=runner,
-            mode=DeploymentMode.DAEMON_THREAD,
-            protocol_adapters=protocol_adapters,
-            **kwargs,
-        )
-
-        # Create uvicorn server
-        config = uvicorn.Config(
-            app=app,
-            host=self.host,
-            port=self.port,
-            loop="asyncio",
-            log_level="info",
-        )
-        self._server = uvicorn.Server(config)
-
-        # Start server in daemon thread
-        def run_server():
-            asyncio.run(self._server.serve())
-
-        self._server_thread = threading.Thread(target=run_server, daemon=True)
-        self._server_thread.start()
+        """
+        Deploy the agent as a FastAPI service (asynchronous version).
 
-        # Wait for server to start
-        await self._wait_for_server_ready()
+        Args:
+            func: Custom processing function
+            endpoint_path: API endpoint path for the processing function
+            request_model: Pydantic model for request validation
+            response_type: Response type - "json", "sse", or "text"
+            before_start: Callback function called before server starts
+            after_finish: Callback function called after server finishes
+            **kwargs: Additional keyword arguments passed to callbacks
 
-        self.is_running = True
-        self.deploy_id = f"daemon_{self.host}_{self.port}"
+        Returns:
+            Dict[str, str]: Dictionary containing deploy_id and url of the
+            deployed service
 
-        self._logger.info(
-            f"FastAPI service started at http://{self.host}:{self.port}",
+        Raises:
+            RuntimeError: If deployment fails
+        """
+        return await self._deploy_async(
+            func=func,
+            endpoint_path=endpoint_path,
+            request_model=request_model,
+            response_type=response_type,
+            before_start=before_start,
+            after_finish=after_finish,
+            protocol_adapters=protocol_adapters,
+            **kwargs,
         )
 
-        return {
-            "deploy_id": self.deploy_id,
-            "url": f"http://{self.host}:{self.port}",
-        }
-
-    async def _deploy_detached_process(
+    async def _deploy_async(
         self,
-        runner: Optional[Any] = None,
-        services_config: Optional[ServicesConfig] = None,
+        func: Callable,
+        endpoint_path: str = "/process",
+        request_model: Optional[Type] = None,
+        response_type: str = "sse",
+        before_start: Optional[Callable] = None,
+        after_finish: Optional[Callable] = None,
         protocol_adapters: Optional[list[ProtocolAdapter]] = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> Dict[str, str]:
-        """Deploy in detached process mode."""
-        self._logger.info(
-            "Deploying FastAPI service in detached process mode...",
-        )
-
-        # Extract agent from runner
-        if not runner or not runner._agent:
-            raise ValueError(
-                "Detached process mode requires a runner with an agent",
-            )
-
-        agent = runner._agent
-
-        # Create package project for detached deployment
-        project_dir = await self.create_detached_project(
-            agent=agent,
-            services_config=services_config,
-            protocol_adapters=protocol_adapters,
-            **kwargs,
-        )
+        if self._is_running:
+            raise RuntimeError("Service is already running")
 
         try:
-            # Start detached process using the packaged project
-            script_path = os.path.join(project_dir, "main.py")
-            pid = await self.process_manager.start_detached_process(
-                script_path=script_path,
+            self._logger.info("Starting FastAPI service deployment...")
+
+            # Store callable configuration
+            self.func = func
+            self.endpoint_path = endpoint_path
+            self.request_model = request_model
+            self.response_type = response_type
+            self.before_start = before_start
+            self.after_finish = after_finish
+            self.kwargs = kwargs
+
+            # Create FastAPI app
+            self._app = self._create_fastapi_app()
+
+            # Support extension protocol
+            if protocol_adapters:
+                for protocol_adapter in protocol_adapters:
+                    protocol_adapter.add_endpoint(app=self._app, func=func)
+
+            # Configure uvicorn server
+            config = uvicorn.Config(
+                self._app,
                 host=self.host,
                 port=self.port,
+                log_level="info",
+                access_log=False,
+                timeout_keep_alive=30,
             )
 
-            self._detached_process_pid = pid
-            self._detached_pid_file = f"/tmp/agentscope_runtime_{pid}.pid"
-
-            # Create PID file
-            self.process_manager.create_pid_file(pid, self._detached_pid_file)
-
-            # Wait for service to become available
-            service_ready = await self.process_manager.wait_for_port(
-                self.host,
-                self.port,
-                timeout=30,
+            self._server = uvicorn.Server(config)
+            # Run the server in a separate thread
+            self._server_thread = threading.Thread(target=self._server.run)
+            self._server_thread.daemon = (
+                True  # Ensure thread doesn't block exit
             )
-
-            if not service_ready:
-                raise RuntimeError("Service did not start within timeout")
-
-            self.is_running = True
-            self.deploy_id = f"detached_{pid}"
-
+            self._server_thread.start()
+
+            # Wait for server to start with timeout
+            start_time = time.time()
+            while not self._is_server_ready():
+                if time.time() - start_time > self._startup_timeout:
+                    # Clean up the thread if server fails to start
+                    if self._server:
+                        self._server.should_exit = True
+                    self._server_thread.join(timeout=self._shutdown_timeout)
+                    raise RuntimeError(
+                        f"Server startup timeout after "
+                        f"{self._startup_timeout} seconds",
+                    )
+                await asyncio.sleep(0.1)
+
+            self._is_running = True
+            url = f"http://{self.host}:{self.port}"
             self._logger.info(
-                f"FastAPI service started in detached process (PID: {pid})",
+                f"FastAPI service deployed successfully at {url}",
             )
-
             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(
-        agent: Any,
-        endpoint_path: str = "/process",
-        requirements: Optional[Union[str, List[str]]] = None,
-        extra_packages: Optional[List[str]] = None,
-        services_config: Optional[ServicesConfig] = None,
-        protocol_adapters: Optional[list[ProtocolAdapter]] = None,
-        **kwargs,  # pylint: disable=unused-argument
-    ) -> str:
-        """Create detached project using package_project method."""
-        if requirements is None:
-            requirements = []
-
-        if isinstance(requirements, str):
-            requirements = [requirements]
-
-        # Create package configuration for detached deployment
-        package_config = PackageConfig(
-            endpoint_path=endpoint_path,
-            deployment_mode="detached_process",
-            extra_packages=extra_packages,
-            protocol_adapters=protocol_adapters,
-            services_config=services_config,
-            requirements=requirements
-            + (
-                ["redis"]
-                if services_config
-                and any(
-                    getattr(config, "provider", None) == "redis"
-                    for config in [
-                        services_config.memory,
-                        services_config.session_history,
-                    ]
-                    if config
-                )
-                else []
-            ),
-        )
-
-        # Use package_project to create the detached project
-        project_dir, _ = package_project(
-            agent=agent,
-            config=package_config,
-        )
-
-        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
-
-        try:
-            if self._detached_process_pid:
-                # Detached process mode
-                await self._stop_detached_process()
-            else:
-                # Daemon thread mode
-                await self._stop_daemon_thread()
-
-        except Exception as e:
-            self._logger.error(f"Failed to stop service: {e}")
-            raise RuntimeError(f"Failed to stop FastAPI service: {e}") from e
-
-    async def _stop_daemon_thread(self):
-        """Stop daemon thread mode service."""
-        self._logger.info("Stopping FastAPI daemon thread service...")
-
-        # Stop the server gracefully
-        if self._server:
-            self._server.should_exit = True
-
-        # Wait for the server thread to finish
-        if self._server_thread and self._server_thread.is_alive():
-            self._server_thread.join(timeout=self._shutdown_timeout)
-            if self._server_thread.is_alive():
-                self._logger.warning(
-                    "Server thread did not terminate, potential resource leak",
-                )
-
-        await self._cleanup_daemon_thread()
-        self.is_running = False
-        self._logger.info("FastAPI daemon thread service stopped successfully")
-
-    async def _stop_detached_process(self):
-        """Stop detached process mode service."""
-        self._logger.info("Stopping FastAPI detached process service...")
-
-        if self._detached_process_pid:
-            await self.process_manager.stop_process_gracefully(
-                self._detached_process_pid,
-            )
-
-        await self._cleanup_detached_process()
-        self.is_running = False
-        self._logger.info(
-            "FastAPI detached process service stopped successfully",
-        )
-
-    async def _cleanup_daemon_thread(self):
-        """Clean up daemon thread resources."""
-        self._server = None
-        self._server_task = None
-        self._server_thread = None
-
-    async def _cleanup_detached_process(self):
-        """Clean up detached process resources."""
-        # Cleanup PID file
-        if self._detached_pid_file:
-            self.process_manager.cleanup_pid_file(self._detached_pid_file)
-
-        # Reset state
-        self._detached_process_pid = None
-        self._detached_pid_file = None
+            self._logger.error(f"Deployment failed: {e}")
+            await self._cleanup_server()
+            raise RuntimeError(f"Failed to deploy FastAPI service: {e}") from e
 
     def _is_server_ready(self) -> bool:
         """Check if the server is ready to accept connections."""
@@ -391,51 +531,56 @@ class LocalDeployManager(DeployManager):
         except Exception:
             return False
 
-    async def _wait_for_server_ready(self, timeout: int = 30):
-        """Wait for server to become ready."""
-        end_time = asyncio.get_event_loop().time() + timeout
+    async def stop(self) -> None:
+        """
+        Stop the FastAPI service.
 
-        while asyncio.get_event_loop().time() < end_time:
-            if self._is_server_ready():
-                return
+        Raises:
+            RuntimeError: If stopping fails
+        """
+        if not self._is_running:
+            self._logger.warning("Service is not running")
+            return
 
-            await asyncio.sleep(0.1)
+        try:
+            self._logger.info("Stopping FastAPI service...")
 
-        raise RuntimeError("Server did not become ready within timeout")
+            # Stop the server gracefully
+            if self._server:
+                self._server.should_exit = True
 
-    def is_service_running(self) -> bool:
-        """Check if service is running."""
-        if not self.is_running:
-            return False
+            # Wait for the server thread to finish
+            if self._server_thread and self._server_thread.is_alive():
+                self._server_thread.join(timeout=self._shutdown_timeout)
+                if self._server_thread.is_alive():
+                    self._logger.warning(
+                        "Server thread did not terminate, "
+                        "potential resource leak",
+                    )
 
-        if self._detached_process_pid:
-            # Check detached process
-            return self.process_manager.is_process_running(
-                self._detached_process_pid,
-            )
-        else:
-            # Check daemon thread
-            return self._server is not None and self._is_server_ready()
-
-    def get_deployment_info(self) -> Dict[str, Any]:
-        """Get deployment information."""
-        return {
-            "deploy_id": self.deploy_id,
-            "host": self.host,
-            "port": self.port,
-            "is_running": self.is_service_running(),
-            "mode": "detached_process"
-            if self._detached_process_pid
-            else "daemon_thread",
-            "pid": self._detached_process_pid,
-            "url": f"http://{self.host}:{self.port}"
-            if self.is_running
-            else None,
-        }
+            await self._cleanup_server()
+            self._is_running = False
+            self._logger.info("FastAPI service stopped successfully")
+
+        except Exception as e:
+            self._logger.error(f"Failed to stop service: {e}")
+            raise RuntimeError(f"Failed to stop FastAPI service: {e}") from e
+
+    async def _cleanup_server(self):
+        """Clean up server resources."""
+        self._server = None
+        self._server_task = None
+        self._server_thread = None
+        self._app = None
+
+    @property
+    def is_running(self) -> bool:
+        """Check if the service is currently running."""
+        return self._is_running
 
     @property
     def service_url(self) -> Optional[str]:
         """Get the current service URL if running."""
-        if self.is_running and self.port:
+        if self._is_running and self.port:
             return f"http://{self.host}:{self.port}"
         return None