agentscope-runtime 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl

agentscope_runtime/engine/deployers/local_deployer.py

@@ -1,586 +1,499 @@
 # -*- coding: utf-8 -*-
+# pylint:disable=protected-access
+
 import asyncio
-import json
 import logging
+import os
 import socket
 import threading
-import time
-import uuid
-from contextlib import asynccontextmanager
-from typing import Optional, Dict, Any, Callable, Type, Tuple, Union
+from typing import Callable, Optional, Type, Any, Dict, Union, List
 
 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 .base import DeployManager
 from .adapter.protocol_adapter import ProtocolAdapter
-from ..schemas.agent_schemas import AgentRequest, AgentResponse, Error
+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,
+)
 
 
 class LocalDeployManager(DeployManager):
-    def __init__(self, host: str = "localhost", port: int = 8090):
-        super().__init__()
-        self.host = host
-        self.port = port
-        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",
-        )
-
-        app_logger = logging.getLogger("app")
-        app_logger.setLevel(logging.INFO)
-
-        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=["*"],
-        )
+    """Unified LocalDeployManager supporting multiple deployment modes."""
 
-    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(
+    def __init__(
         self,
-        user_id: str,
-        request_body_obj: Any,
-        request_id: str,
+        host: str = "127.0.0.1",
+        port: int = 8000,
+        shutdown_timeout: int = 30,
+        startup_timeout: int = 30,
+        logger: Optional[logging.Logger] = None,
     ):
-        """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)
+        """Initialize LocalDeployManager.
 
-    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
+        Args:
+            host: Host to bind to
+            port: Port to bind to
+            shutdown_timeout: Timeout for graceful shutdown
+            logger: Logger instance
+        """
+        super().__init__()
+        self.host = host
+        self.port = port
+        self._shutdown_timeout = shutdown_timeout
+        self._startup_timeout = startup_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,
+        )
 
-    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()
+        # Template manager
+        self.template_manager = FastAPITemplateManager()
 
-    def deploy_sync(
+    async def deploy(
         self,
-        func: Callable,
+        app=None,
+        runner: Optional[Any] = None,
         endpoint_path: str = "/process",
-        request_model: Optional[Type] = AgentRequest,
+        request_model: Optional[Type] = None,
         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,
+        custom_endpoints: Optional[List[Dict]] = None,
+        protocol_adapters: Optional[list[ProtocolAdapter]] = None,
+        broker_url: Optional[str] = None,
+        backend_url: Optional[str] = None,
+        enable_embedded_worker: bool = False,
         **kwargs: Any,
     ) -> Dict[str, str]:
-        """
-        Deploy the agent as a FastAPI service (synchronous version).
+        """Deploy using unified FastAPI architecture.
 
         Args:
-            func: Custom processing function
-            endpoint_path: API endpoint path for the processing function
+            runner: Runner instance (for DAEMON_THREAD mode)
+            endpoint_path: API endpoint path
             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
-            **kwargs: Additional keyword arguments passed to callbacks
+            mode: Deployment mode
+            services_config: Services configuration
+            custom_endpoints: Custom endpoints from agent app
+            protocol_adapters: Protocol adapters
+            broker_url: Celery broker URL for background task processing
+            backend_url: Celery backend URL for result storage
+            enable_embedded_worker: Whether to run Celery worker
+                embedded in the app
+            **kwargs: Additional keyword arguments
 
         Returns:
-            Dict[str, str]: Dictionary containing deploy_id and url of the
-            deployed service
+            Dict containing deploy_id and url
 
         Raises:
             RuntimeError: If deployment fails
         """
-        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,
-            ),
-        )
+        if self.is_running:
+            raise RuntimeError("Service is already running")
 
-    async def deploy(
+        self._app = app
+        if self._app is not None:
+            runner = self._app._runner
+            endpoint_path = self._app.endpoint_path
+            response_type = self._app.response_type
+            stream = self._app.stream
+            request_model = self._app.request_model
+            before_start = self._app.before_start
+            after_finish = self._app.after_finish
+            backend_url = self._app.backend_url
+            broker_url = self._app.broker_url
+            custom_endpoints = self._app.custom_endpoints
+            protocol_adapters = self._app.protocol_adapters
+        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,
+                    custom_endpoints=custom_endpoints,
+                    protocol_adapters=protocol_adapters,
+                    broker_url=broker_url,
+                    backend_url=backend_url,
+                    enable_embedded_worker=enable_embedded_worker,
+                    **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,
+                    custom_endpoints=custom_endpoints,
+                    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
+
+    async def _deploy_daemon_thread(
         self,
-        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,
+        runner: Optional[Any] = None,
         protocol_adapters: Optional[list[ProtocolAdapter]] = None,
-        **kwargs: Any,
+        broker_url: Optional[str] = None,
+        backend_url: Optional[str] = None,
+        enable_embedded_worker: bool = False,
+        **kwargs,
     ) -> Dict[str, str]:
-        """
-        Deploy the agent as a FastAPI service (asynchronous version).
-
-        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
-
-        Returns:
-            Dict[str, str]: Dictionary containing deploy_id and url of the
-            deployed service
+        """Deploy in daemon thread mode."""
+        self._logger.info("Deploying FastAPI service in daemon thread mode...")
 
-        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,
+        # Create FastAPI app using factory with Celery support
+        app = FastAPIAppFactory.create_app(
+            runner=runner,
+            mode=DeploymentMode.DAEMON_THREAD,
             protocol_adapters=protocol_adapters,
+            broker_url=broker_url,
+            backend_url=backend_url,
+            enable_embedded_worker=enable_embedded_worker,
             **kwargs,
         )
 
-    async def _deploy_async(
+        # 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()
+
+        # Wait for server to start
+        await self._wait_for_server_ready(self._startup_timeout)
+
+        self.is_running = True
+        self.deploy_id = f"daemon_{self.host}_{self.port}"
+
+        self._logger.info(
+            f"FastAPI service started at http://{self.host}:{self.port}",
+        )
+
+        return {
+            "deploy_id": self.deploy_id,
+            "url": f"http://{self.host}:{self.port}",
+        }
+
+    async def _deploy_detached_process(
         self,
-        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,
+        runner: Optional[Any] = None,
+        services_config: Optional[ServicesConfig] = None,
         protocol_adapters: Optional[list[ProtocolAdapter]] = None,
-        **kwargs: Any,
+        **kwargs,
     ) -> Dict[str, str]:
-        if self._is_running:
-            raise RuntimeError("Service is already running")
+        """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
+        if "agent" in kwargs:
+            kwargs.pop("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,
+        )
 
         try:
-            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,
+            # 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,
                 host=self.host,
                 port=self.port,
-                log_level="info",
-                access_log=False,
-                timeout_keep_alive=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
+            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_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}"
+
+            if not service_ready:
+                raise RuntimeError("Service did not start within timeout")
+
+            self.is_running = True
+            self.deploy_id = f"detached_{pid}"
+
             self._logger.info(
-                f"FastAPI service deployed successfully at {url}",
+                f"FastAPI service started in detached process (PID: {pid})",
             )
+
             return {
                 "deploy_id": self.deploy_id,
-                "url": url,
+                "url": f"http://{self.host}:{self.port}",
             }
 
         except Exception as e:
-            self._logger.error(f"Deployment failed: {e}")
-            await self._cleanup_server()
-            raise RuntimeError(f"Failed to deploy FastAPI service: {e}") from e
+            # Cleanup on failure
+            if os.path.exists(project_dir):
+                try:
+                    import shutil
 
-    def _is_server_ready(self) -> bool:
-        """Check if the server is ready to accept connections."""
-        try:
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                s.settimeout(0.1)
-                result = s.connect_ex((self.host, self.port))
-                return result == 0
-        except Exception:
-            return False
+                    shutil.rmtree(project_dir)
+                except OSError:
+                    pass
+            raise e
 
-    async def stop(self) -> None:
-        """
-        Stop the FastAPI service.
+    @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,
+        custom_endpoints: Optional[
+            List[Dict]
+        ] = None,  # New parameter for custom endpoints
+        # Celery parameters
+        broker_url: Optional[str] = None,
+        backend_url: Optional[str] = None,
+        enable_embedded_worker: bool = False,
+        **kwargs,  # pylint: disable=unused-argument
+    ) -> str:
+        """Create detached project using package_project method."""
+        if requirements is None:
+            requirements = []
 
-        Raises:
-            RuntimeError: If stopping fails
-        """
-        if not self._is_running:
-            self._logger.warning("Service is not running")
-            return
+        if isinstance(requirements, str):
+            requirements = [requirements]
 
-        try:
-            self._logger.info("Stopping FastAPI service...")
+        # 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,
+            custom_endpoints=custom_endpoints,  # Add custom endpoints
+            # Celery configuration
+            broker_url=broker_url,
+            backend_url=backend_url,
+            enable_embedded_worker=enable_embedded_worker,
+            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 []
+            )
+            + (
+                [
+                    "celery",
+                    "redis",
+                ]  # Add Celery and Redis if Celery is configured
+                if broker_url or backend_url
+                else []
+            ),
+        )
+
+        # Use package_project to create the detached project
+        project_dir, _ = package_project(
+            agent=agent,
+            config=package_config,
+        )
 
-            # Stop the server gracefully
-            if self._server:
-                self._server.should_exit = True
+        return project_dir
 
-            # 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",
-                    )
+    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
 
-            await self._cleanup_server()
-            self._is_running = False
-            self._logger.info("FastAPI service stopped successfully")
+        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 _cleanup_server(self):
-        """Clean up server resources."""
+    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
-        self._app = None
 
-    @property
-    def is_running(self) -> bool:
-        """Check if the service is currently running."""
-        return self._is_running
+    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
+
+    def _is_server_ready(self) -> bool:
+        """Check if the server is ready to accept connections."""
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.settimeout(0.1)
+                result = s.connect_ex((self.host, self.port))
+                return result == 0
+        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
+
+        while asyncio.get_event_loop().time() < end_time:
+            if self._is_server_ready():
+                return
+
+            await asyncio.sleep(0.1)
+
+        raise RuntimeError("Server did not become ready within timeout")
+
+    def is_service_running(self) -> bool:
+        """Check if service is running."""
+        if not self.is_running:
+            return False
+
+        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,
+        }
 
     @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