llama-deploy-appserver 0.3.0a6__tar.gz → 0.3.0a8__tar.gz

{llama_deploy_appserver-0.3.0a6 → llama_deploy_appserver-0.3.0a8}/PKG-INFO

@@ -1,16 +1,16 @@
 Metadata-Version: 2.3
 Name: llama-deploy-appserver
-Version: 0.3.0a6
+Version: 0.3.0a8
 Summary: Application server components for LlamaDeploy
 Author: Massimiliano Pippi
 Author-email: Massimiliano Pippi <mpippi@gmail.com>
 License: MIT
-Requires-Dist: llama-index-workflows>=1.1.0
+Requires-Dist: llama-index-workflows[server]>=1.3.0
 Requires-Dist: pydantic-settings>=2.10.1
 Requires-Dist: uvicorn>=0.24.0
 Requires-Dist: fastapi>=0.100.0
 Requires-Dist: websockets>=12.0
-Requires-Dist: llama-deploy-core>=0.3.0a6,<0.4.0
+Requires-Dist: llama-deploy-core>=0.3.0a8,<0.4.0
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: prometheus-fastapi-instrumentator>=7.1.0
 Requires-Dist: packaging>=25.0

{llama_deploy_appserver-0.3.0a6 → llama_deploy_appserver-0.3.0a8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "llama-deploy-appserver"
-version = "0.3.0a6"
+version = "0.3.0a8"
 description = "Application server components for LlamaDeploy"
 readme = "README.md"
 license = { text = "MIT" }
@@ -9,12 +9,12 @@ authors = [
 ]
 requires-python = ">=3.12, <4"
 dependencies = [
-    "llama-index-workflows>=1.1.0",
+    "llama-index-workflows[server]>=1.3.0",
     "pydantic-settings>=2.10.1",
     "uvicorn>=0.24.0",
     "fastapi>=0.100.0",
     "websockets>=12.0",
-    "llama-deploy-core>=0.3.0a6,<0.4.0",
+    "llama-deploy-core>=0.3.0a8,<0.4.0",
     "httpx>=0.28.1",
     "prometheus-fastapi-instrumentator>=7.1.0",
     "packaging>=25.0",

{llama_deploy_appserver-0.3.0a6 → llama_deploy_appserver-0.3.0a8}/src/llama_deploy/appserver/app.py

@@ -5,12 +5,14 @@ import threading
 import time
 import webbrowser
 from contextlib import asynccontextmanager
+from importlib.metadata import version
 from pathlib import Path
 from typing import Any, AsyncGenerator
 
 import uvicorn
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.openapi.utils import get_openapi
 from llama_deploy.appserver.deployment_config_parser import (
     get_deployment_config,
 )
@@ -26,14 +28,17 @@ from llama_deploy.appserver.settings import configure_settings, settings
 from llama_deploy.appserver.workflow_loader import (
     _exclude_venv_warning,
     build_ui,
-    find_python_pyproject,
     inject_appserver_into_target,
     install_ui,
     load_environment_variables,
     load_workflows,
     start_dev_ui_process,
 )
+from llama_deploy.core.config import DEFAULT_DEPLOYMENT_FILE_PATH
 from prometheus_fastapi_instrumentator import Instrumentator
+from starlette.routing import Route
+from starlette.schemas import SchemaGenerator
+from workflows.server import WorkflowServer
 
 from .deployment import Deployment
 from .process_utils import run_process
@@ -52,12 +57,28 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, Any]:
     deployment = Deployment(workflows)
     base_router = create_base_router(config.name)
     deploy_router = create_deployments_router(config.name, deployment)
+    server = deployment.create_workflow_server()
+
+    for route in server.app.routes:
+        # add routes directly rather than mounting, so that we can share a root
+        if isinstance(route, Route):
+            app.add_api_route(
+                f"/deployments/{config.name}{route.path}",
+                route.endpoint,
+                name=f"{config.name}_{route.name}",
+                methods=route.methods,
+                include_in_schema=True,  # change to false when schemas are added to workflow server
+                tags=["workflows"],
+            )
+
     app.include_router(base_router)
     app.include_router(deploy_router)
-    # proxy UI in dev mode
+
+    _setup_openapi(config.name, app, server)
+
     if config.ui is not None:
         if settings.proxy_ui:
-            ui_router = create_ui_proxy_router(config.name, config.ui.port)
+            ui_router = create_ui_proxy_router(config.name, settings.proxy_ui_port)
             app.include_router(ui_router)
         else:
             # otherwise serve the pre-built if available
@@ -69,6 +90,50 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, Any]:
     apiserver_state.state("stopped")
 
 
+def _setup_openapi(name: str, app: FastAPI, server: WorkflowServer) -> None:
+    """
+    extends the fastapi based openapi schema with starlette generated schema
+    """
+    schema_title = "Llama Deploy App Server"
+    app_version = version("llama-deploy-appserver")
+
+    prefix = f"/deployments/{name}"
+    workflow_routes = [x for x in server.app.routes if isinstance(x, Route)]
+    server_app_routes = []
+    for route in workflow_routes:
+        server_app_routes.append(
+            Route(
+                path=prefix + route.path,
+                endpoint=route.endpoint,
+                methods=route.methods,
+                name=route.name,
+                include_in_schema=route.include_in_schema,
+            )
+        )
+
+    schemas = SchemaGenerator(
+        {"openapi": "3.0.0", "info": {"title": schema_title, "version": app_version}}
+    )
+    starlette_schema = schemas.get_schema(server_app_routes)
+
+    def custom_openapi():
+        if app.openapi_schema:
+            return app.openapi_schema
+        openapi_schema = get_openapi(
+            title=schema_title,
+            version=app_version,
+            routes=app.routes + server_app_routes,
+        )
+        openapi_schema["paths"] = {
+            **openapi_schema["paths"],
+            **starlette_schema["paths"],
+        }
+        app.openapi_schema = openapi_schema
+        return app.openapi_schema
+
+    app.openapi = custom_openapi  # ty: ignore[invalid-assignment] - doesn't like us overwriting the method
+
+
 app = FastAPI(lifespan=lifespan)
 Instrumentator().instrument(app).expose(app)
 
@@ -98,14 +163,16 @@ def prepare_server(
     install: bool = False,
     build: bool = False,
 ) -> None:
-    configure_settings(deployment_file_path=deployment_file)
-    load_environment_variables(get_deployment_config(), settings.config_parent)
+    configure_settings(
+        deployment_file_path=deployment_file or Path(DEFAULT_DEPLOYMENT_FILE_PATH)
+    )
+    load_environment_variables(get_deployment_config(), settings.resolved_config_parent)
     if install:
         config = get_deployment_config()
-        inject_appserver_into_target(config, settings.config_parent)
-        install_ui(config, settings.config_parent)
+        inject_appserver_into_target(config, settings.resolved_config_parent)
+        install_ui(config, settings.resolved_config_parent)
     if build:
-        build_ui(settings.config_parent, get_deployment_config())
+        build_ui(settings.resolved_config_parent, get_deployment_config(), settings)
 
 
 def start_server(
@@ -119,15 +186,15 @@ def start_server(
     configure_settings(
         proxy_ui=proxy_ui,
         app_root=cwd,
-        deployment_file_path=deployment_file,
+        deployment_file_path=deployment_file or Path(DEFAULT_DEPLOYMENT_FILE_PATH),
         reload=reload,
     )
-    load_environment_variables(get_deployment_config(), settings.config_parent)
+    load_environment_variables(get_deployment_config(), settings.resolved_config_parent)
 
     ui_process = None
     if proxy_ui:
         ui_process = start_dev_ui_process(
-            settings.config_parent, settings.port, get_deployment_config()
+            settings.resolved_config_parent, settings, get_deployment_config()
         )
     try:
         if open_browser:
@@ -150,11 +217,20 @@ def start_server_in_target_venv(
     cwd: Path | None = None,
     deployment_file: Path | None = None,
     open_browser: bool = False,
+    port: int | None = None,
+    ui_port: int | None = None,
 ) -> None:
-    cfg = get_deployment_config()
-    path = find_python_pyproject(cwd or Path.cwd(), cfg)
+    # Ensure settings reflect the intended working directory before computing paths
 
-    args = ["uv", "run", "python", "-m", "llama_deploy.appserver.app"]
+    configure_settings(
+        app_root=cwd,
+        deployment_file_path=deployment_file,
+        reload=reload,
+        proxy_ui=proxy_ui,
+    )
+    base_dir = cwd or Path.cwd()
+    path = settings.resolved_config_parent.relative_to(base_dir)
+    args = ["uv", "run", "--no-progress", "python", "-m", "llama_deploy.appserver.app"]
     if proxy_ui:
         args.append("--proxy-ui")
     if reload:
@@ -164,11 +240,17 @@ def start_server_in_target_venv(
         args.append(str(deployment_file))
     if open_browser:
         args.append("--open-browser")
-    # All the streaming/PTY/pipe handling is centralized
+
+    env = os.environ.copy()
+    if port:
+        env["LLAMA_DEPLOY_APISERVER_PORT"] = str(port)
+    if ui_port:
+        env["LLAMA_DEPLOY_APISERVER_PROXY_UI_PORT"] = str(ui_port)
+
     ret = run_process(
         args,
         cwd=path,
-        env=None,
+        env=env,
         line_transform=_exclude_venv_warning,
     )
 
@@ -177,7 +259,6 @@ def start_server_in_target_venv(
 
 
 if __name__ == "__main__":
-    print("starting server")
     parser = argparse.ArgumentParser()
     parser.add_argument("--proxy-ui", action="store_true")
     parser.add_argument("--reload", action="store_true")

{llama_deploy_appserver-0.3.0a6 → llama_deploy_appserver-0.3.0a8}/src/llama_deploy/appserver/bootstrap.py

@@ -8,7 +8,11 @@ import os
 from pathlib import Path
 
 from llama_deploy.appserver.deployment_config_parser import get_deployment_config
-from llama_deploy.appserver.settings import BootstrapSettings, configure_settings
+from llama_deploy.appserver.settings import (
+    BootstrapSettings,
+    configure_settings,
+    settings,
+)
 from llama_deploy.appserver.workflow_loader import (
     build_ui,
     inject_appserver_into_target,
@@ -45,8 +49,7 @@ def bootstrap_app_from_repo(
         deployment_file_path=Path(bootstrap_settings.deployment_file_path),
     )
     config = get_deployment_config()
-    base_path = Path(target_dir)
-    load_environment_variables(config, base_path)
+    load_environment_variables(config, settings.resolved_config_parent)
 
     sdists = None
     if bootstrap_settings.bootstrap_sdists:
@@ -59,9 +62,9 @@ def bootstrap_app_from_repo(
             sdists = None
     # Use the explicit base path rather than relying on global settings so tests
     # can safely mock configure_settings without affecting call arguments.
-    inject_appserver_into_target(config, base_path, sdists)
-    install_ui(config, base_path)
-    build_ui(base_path, config)
+    inject_appserver_into_target(config, settings.resolved_config_parent, sdists)
+    install_ui(config, settings.resolved_config_parent)
+    build_ui(settings.resolved_config_parent, config, settings)
 
     pass
 

{llama_deploy_appserver-0.3.0a6 → llama_deploy_appserver-0.3.0a8}/src/llama_deploy/appserver/deployment.py

@@ -7,6 +7,7 @@ from llama_deploy.appserver.types import generate_id
 from llama_deploy.appserver.workflow_loader import DEFAULT_SERVICE_ID
 from workflows import Context, Workflow
 from workflows.handler import WorkflowHandler
+from workflows.server import WorkflowServer
 
 logger = logging.getLogger()
 
@@ -78,3 +79,9 @@ class Deployment:
         self._handlers[handler_id] = handler
         self._handler_inputs[handler_id] = json.dumps(run_kwargs)
         return handler_id, session_id
+
+    def create_workflow_server(self) -> WorkflowServer:
+        server = WorkflowServer()
+        for service_id, workflow in self._workflow_services.items():
+            server.add_workflow(service_id, workflow)
+        return server

{llama_deploy_appserver-0.3.0a6 → llama_deploy_appserver-0.3.0a8}/src/llama_deploy/appserver/deployment_config_parser.py

@@ -1,13 +1,15 @@
 import functools
 
 from llama_deploy.appserver.settings import BootstrapSettings, settings
-from llama_deploy.core.deployment_config import DeploymentConfig
+from llama_deploy.core.deployment_config import DeploymentConfig, read_deployment_config
 
 
-@functools.lru_cache
+@functools.cache
 def get_deployment_config() -> DeploymentConfig:
     base_settings = BootstrapSettings()
     base = settings.app_root.resolve()
-    yaml_file = base / settings.deployment_file_path
     name = base_settings.deployment_name
-    return DeploymentConfig.from_yaml(yaml_file, name)
+    parsed = read_deployment_config(base, settings.deployment_file_path)
+    if name is not None:
+        parsed.name = name
+    return parsed

{llama_deploy_appserver-0.3.0a6 → llama_deploy_appserver-0.3.0a8}/src/llama_deploy/appserver/process_utils.py

@@ -30,6 +30,7 @@ def run_process(
     threads: list[threading.Thread] = []
     try:
         cleanup()
+        _log_command(cmd, prefixer)
         threads = _start_stream_threads(sources, prefixer)
         ret = process.wait()
         if ret != 0:
@@ -58,6 +59,7 @@ def spawn_process(
 
     process, sources, cleanup = _spawn_process(cmd, cwd=cwd, env=env, use_pty=use_pty)
     cleanup()
+    _log_command(cmd, prefixer)
     _start_stream_threads(sources, prefixer)
     return process
 
@@ -187,6 +189,13 @@ def _stream_source(
             pass
 
 
+def _log_command(cmd: list[str], transform: Callable[[str], str | None] | None) -> None:
+    cmd_str = "> " + " ".join(cmd)
+    if transform:
+        cmd_str = transform(cmd_str)
+    sys.stderr.write(cmd_str + "\n")
+
+
 def _start_stream_threads(
     sources: list[tuple[int | TextIO, TextIO]],
     transform: Callable[[str], str | None] | None,

{llama_deploy_appserver-0.3.0a6 → llama_deploy_appserver-0.3.0a8}/src/llama_deploy/appserver/routers/deployments.py

@@ -33,9 +33,7 @@ def create_base_router(name: str) -> APIRouter:
     return base_router
 
 
-def create_deployments_router(
-    name: str, deployment: Deployment, serve_static: bool = False
-) -> APIRouter:
+def create_deployments_router(name: str, deployment: Deployment) -> APIRouter:
     deployments_router = APIRouter(
         prefix="/deployments",
     )

{llama_deploy_appserver-0.3.0a6 → llama_deploy_appserver-0.3.0a8}/src/llama_deploy/appserver/routers/ui_proxy.py

@@ -1,6 +1,6 @@
 import asyncio
 import logging
-from typing import List, Optional
+from typing import List
 
 import httpx
 import websockets
@@ -120,10 +120,12 @@ def create_ui_proxy_router(name: str, port: int) -> APIRouter:
     @deployment_router.api_route(
         "/ui/{path:path}",
         methods=["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD", "PATCH"],
+        include_in_schema=False,
     )
     @deployment_router.api_route(
         "/ui",
         methods=["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD", "PATCH"],
+        include_in_schema=False,
     )
     async def proxy(
         request: Request,
@@ -197,17 +199,17 @@ def create_ui_proxy_router(name: str, port: int) -> APIRouter:
 def mount_static_files(
     app: FastAPI, config: DeploymentConfig, settings: ApiserverSettings
 ) -> None:
-    if not config.ui or not config.ui.source:
+    path = settings.app_root / config.build_output_path()
+    if not path:
         return
 
-    ui_path = settings.config_parent / config.ui.source.location / "dist"
-    if not ui_path.exists():
+    if not path.exists():
         return
 
     # Serve index.html when accessing the directory path
     app.mount(
         f"/deployments/{config.name}/ui",
-        StaticFiles(directory=str(ui_path), html=True),
+        StaticFiles(directory=str(path), html=True),
         name=f"ui-static-{config.name}",
     )
     return None

{llama_deploy_appserver-0.3.0a6 → llama_deploy_appserver-0.3.0a8}/src/llama_deploy/appserver/settings.py

@@ -2,6 +2,7 @@ import os
 from pathlib import Path
 
 from llama_deploy.core.config import DEFAULT_DEPLOYMENT_FILE_PATH
+from llama_deploy.core.deployment_config import resolve_config_parent
 from pydantic import Field
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
@@ -24,7 +25,7 @@ class BootstrapSettings(BaseSettings):
     )
     git_sha: str | None = Field(default=None, description="The git SHA to checkout")
     deployment_file_path: str = Field(
-        default="llama_deploy.yaml",
+        default=".",
         description="The path to the deployment file, relative to the root of the repository",
     )
     deployment_name: str | None = Field(
@@ -55,13 +56,17 @@ class ApiserverSettings(BaseSettings):
 
     deployment_file_path: Path = Field(
         default=Path(DEFAULT_DEPLOYMENT_FILE_PATH),
-        description="path, relative to the repository root, where the deployment file is located. If not provided, will look for ./llama_deploy.yaml",
+        description="path, relative to the repository root, where the pyproject.toml file is located",
     )
 
     proxy_ui: bool = Field(
         default=False,
         description="If true, proxy a development UI server instead of serving built assets",
     )
+    proxy_ui_port: int = Field(
+        default=4502,
+        description="The TCP port where to bind the UI proxy server",
+    )
 
     reload: bool = Field(
         default=False,
@@ -69,8 +74,8 @@ class ApiserverSettings(BaseSettings):
     )
 
     @property
-    def config_parent(self) -> Path:
-        return (self.app_root / self.deployment_file_path).parent
+    def resolved_config_parent(self) -> Path:
+        return resolve_config_parent(self.app_root, self.deployment_file_path)
 
 
 settings = ApiserverSettings()

{llama_deploy_appserver-0.3.0a6 → llama_deploy_appserver-0.3.0a8}/src/llama_deploy/appserver/workflow_loader.py

@@ -13,9 +13,11 @@ from llama_deploy.appserver.deployment_config_parser import (
     DeploymentConfig,
 )
 from llama_deploy.appserver.process_utils import run_process, spawn_process
+from llama_deploy.appserver.settings import ApiserverSettings, settings
 from llama_deploy.core.ui_build import ui_build_output_path
 from packaging.version import InvalidVersion, Version
 from workflows import Workflow
+from workflows.server import WorkflowServer
 
 logger = logging.getLogger(__name__)
 
@@ -27,44 +29,28 @@ def load_workflows(config: DeploymentConfig) -> dict[str, Workflow]:
     Creates WorkflowService instances according to the configuration object.
 
     """
-    workflow_services = {}
-
-    # Pre-compute per-service import info
-    per_service: list[tuple[str, str]] = []
-    for service_id, service_config in config.services.items():
-        if service_config.import_path is None:
-            continue
-        raw_mod_path, workflow_name = service_config.import_path.split(":", 1)
-        module_name = Path(raw_mod_path).name
-        per_service.append((service_id, workflow_name))
-
-    for service_id, workflow_name in per_service:
-        import_path = config.services[service_id].import_path
-        if import_path is None:
-            continue
-        raw_mod_path = import_path.split(":", 1)[0]
-        module_name = Path(raw_mod_path).name
+    workflow_services: dict[str, Workflow] = {}
 
+    if config.app:
+        module_name, app_name = config.app.split(":", 1)
         module = importlib.import_module(module_name)
-
-        if hasattr(module, workflow_name):
+        workflow = getattr(module, app_name)
+        if not isinstance(workflow, WorkflowServer):
+            raise ValueError(
+                f"Workflow {app_name} in {module_name} is not a WorkflowServer object"
+            )
+        # kludge to get the workflows
+        workflow_services = workflow._workflows
+    else:
+        for service_id, workflow_name in config.workflows.items():
+            module_name, workflow_name = workflow_name.split(":", 1)
+            module = importlib.import_module(module_name)
             workflow = getattr(module, workflow_name)
             if not isinstance(workflow, Workflow):
                 logger.warning(
                     f"Workflow {workflow_name} in {module_name} is not a Workflow object",
                 )
             workflow_services[service_id] = workflow
-        else:
-            logger.warning("Workflow %s not found in %s", workflow_name, module_name)
-
-    if config.default_service:
-        if config.default_service in workflow_services:
-            workflow_services[DEFAULT_SERVICE_ID] = workflow_services[
-                config.default_service
-            ]
-        else:
-            msg = f"Service with id '{config.default_service}' does not exist, cannot set it as default."
-            logger.warning(msg)
 
     return workflow_services
 
@@ -73,15 +59,14 @@ def load_environment_variables(config: DeploymentConfig, source_root: Path) -> N
     """
     Load environment variables from the deployment config.
     """
-    for service_id, service_config in config.services.items():
-        env_vars = {**service_config.env} if service_config.env else {}
-        for env_file in service_config.env_files or []:
-            env_file_path = source_root / env_file
-            values = dotenv_values(env_file_path)
-            env_vars.update(**values)
-        for key, value in env_vars.items():
-            if value:
-                os.environ[key] = value
+    env_vars = {**config.env} if config.env else {}
+    for env_file in config.env_files or []:
+        env_file_path = source_root / env_file
+        values = dotenv_values(env_file_path)
+        env_vars.update(**values)
+    for key, value in env_vars.items():
+        if value:
+            os.environ[key] = value
 
 
 @functools.cache
@@ -116,12 +101,7 @@ def inject_appserver_into_target(
         source_root: The root directory of the deployment
         sdists: A list of tar.gz sdists files to install instead of installing the appserver
     """
-    path = _find_install_target(source_root, config)
-    if path is None:
-        logger.warning(
-            "No python_dependencies and no root pyproject.toml; skipping dependency installation."
-        )
-        return
+    path = settings.resolved_config_parent
     logger.info(f"Installing ensuring venv at {path} and adding appserver to it")
     _ensure_uv_available()
     _add_appserver_if_missing(path, source_root, sdists=sdists)
@@ -178,69 +158,61 @@ def _add_appserver_if_missing(
         )
         return
 
-    def ensure_venv(path: Path) -> Path:
+    def run_uv(cmd: str, args: list[str]):
+        run_process(
+            ["uv", cmd] + args,
+            cwd=source_root / path,
+            prefix=f"[uv {cmd}]",
+            color_code="36",
+            use_tty=False,
+            line_transform=_exclude_venv_warning,
+        )
+
+    def ensure_venv(path: Path, force: bool = False) -> Path:
         venv_path = source_root / path / ".venv"
-        if not venv_path.exists():
-            run_process(
-                ["uv", "venv", str(venv_path)],
-                cwd=source_root / path,
-                prefix="[uv venv]",
-                color_code="36",
-            )
+        if force or not venv_path.exists():
+            run_uv("venv", [str(venv_path)])
         return venv_path
 
     if sdists:
-        run_process(
-            ["uv", "pip", "install"]
+        run_uv(
+            "pip",
+            ["install"]
             + [str(s.absolute()) for s in sdists]
             + ["--prefix", str(ensure_venv(path))],
-            cwd=source_root / path,
-            prefix="[uv pip install]",
-            color_code="36",
         )
     elif are_we_editable_mode():
         pyproject = _find_development_pyproject()
         if pyproject is None:
             raise RuntimeError("No pyproject.toml found in llama-deploy-appserver")
         target = f"file://{str(pyproject.relative_to(source_root.resolve() / path, walk_up=True))}"
-        run_process(
+
+        run_uv(
+            "pip",
             [
-                "uv",
-                "pip",
                 "install",
-                "--reinstall",
+                "--reinstall-package",
+                "llama-deploy-appserver",
                 target,
                 "--prefix",
-                str(ensure_venv(path)),
+                str(ensure_venv(path, force=True)),
             ],
-            cwd=source_root / path,
-            prefix="[uv pip install]",
-            color_code="36",
         )
+
     else:
         version = _is_missing_or_outdated(path)
         if version is not None:
             if save_version:
-                run_process(
-                    ["uv", "add", f"llama-deploy-appserver>={version}"],
-                    cwd=source_root / path,
-                    prefix="[uv add]",
-                    color_code="36",
-                    line_transform=_exclude_venv_warning,
-                )
+                run_uv("add", [f"llama-deploy-appserver>={version}"])
             else:
-                run_process(
+                run_uv(
+                    "pip",
                     [
-                        "uv",
-                        "pip",
                         "install",
                         f"llama-deploy-appserver=={version}",
                         "--prefix",
                         str(ensure_venv(path)),
                     ],
-                    cwd=source_root / path,
-                    prefix="[uv pip install]",
-                    color_code="36",
                 )
 
 
@@ -253,27 +225,6 @@ def _find_development_pyproject() -> Path | None:
     return dir
 
 
-def find_python_pyproject(base: Path, config: DeploymentConfig) -> Path | None:
-    path: Path | None = None
-    for service_id, service_config in config.services.items():
-        if service_config.python_dependencies:
-            if len(service_config.python_dependencies) > 1:
-                logger.warning(
-                    "Llama Deploy now only supports installing from a single pyproject.toml path"
-                )
-            this_path = Path(service_config.python_dependencies[0])
-            if path is not None and this_path != path:
-                logger.warning(
-                    f"Llama Deploy now only supports installing from a single pyproject.toml path, ignoring {this_path}"
-                )
-            else:
-                path = this_path
-    if path is None:
-        if (base / "pyproject.toml").exists():
-            path = Path(".")
-    return path
-
-
 def _exclude_venv_warning(line: str) -> str | None:
     if "use `--active` to target the active environment instead" in line:
         return None
@@ -311,82 +262,56 @@ def _ensure_uv_available() -> None:
             raise RuntimeError(msg)
 
 
-def _find_install_target(base: Path, config: DeploymentConfig) -> Path | None:
-    return find_python_pyproject(base, config)
-
-
-def _validate_path_is_safe(
-    path: Path, source_root: Path, path_type: str = "path"
-) -> None:
-    """Validates that a path is within the source root to prevent path traversal attacks.
-
-    Args:
-        path: The path to validate
-        source_root: The root directory that paths should be relative to
-        path_type: Description of the path type for error messages
-
-    Raises:
-        DeploymentError: If the path is outside the source root
-    """
-    resolved_path = (source_root / path).resolve()
-    resolved_source_root = source_root.resolve()
-
-    if not resolved_path.is_relative_to(resolved_source_root):
-        msg = (
-            f"{path_type} {path} is not a subdirectory of the source root {source_root}"
-        )
-        raise RuntimeError(msg)
-
-
 def install_ui(config: DeploymentConfig, config_parent: Path) -> None:
     if config.ui is None:
         return
-    path = Path(config.ui.source.location) if config.ui.source else Path(".")
-    _validate_path_is_safe(path, config_parent, "ui_source")
+    package_manager = config.ui.package_manager
     run_process(
-        ["pnpm", "install"],
-        cwd=config_parent / path,
-        prefix="[pnpm install]",
+        [package_manager, "install"],
+        cwd=config_parent / config.ui.directory,
+        prefix=f"[{package_manager} install]",
         color_code="33",
     )
 
 
-def _ui_env(config: DeploymentConfig) -> dict[str, str]:
+def _ui_env(config: DeploymentConfig, settings: ApiserverSettings) -> dict[str, str]:
     env = os.environ.copy()
     env["LLAMA_DEPLOY_DEPLOYMENT_URL_ID"] = config.name
     env["LLAMA_DEPLOY_DEPLOYMENT_BASE_PATH"] = f"/deployments/{config.name}/ui"
     if config.ui is not None:
-        env["PORT"] = str(config.ui.port)
+        env["PORT"] = str(settings.proxy_ui_port)
     return env
 
 
-def build_ui(config_parent: Path, config: DeploymentConfig) -> bool:
+def build_ui(
+    config_parent: Path, config: DeploymentConfig, settings: ApiserverSettings
+) -> bool:
     """
     Returns True if the UI was built (and supports building), otherwise False if there's no build command
     """
     if config.ui is None:
         return False
-    path = Path(config.ui.source.location) if config.ui.source else Path(".")
-    _validate_path_is_safe(path, config_parent, "ui_source")
-    env = _ui_env(config)
+    path = Path(config.ui.directory)
+    env = _ui_env(config, settings)
 
     has_build = ui_build_output_path(config_parent, config)
     if has_build is None:
         return False
 
     run_process(
-        ["pnpm", "run", "build"],
+        ["npm", "run", "build"],
         cwd=config_parent / path,
         env=env,
-        prefix="[pnpm run build]",
+        prefix="[npm run build]",
         color_code="34",
     )
     return True
 
 
 def start_dev_ui_process(
-    root: Path, main_port: int, config: DeploymentConfig
+    root: Path, settings: ApiserverSettings, config: DeploymentConfig
 ) -> None | subprocess.Popen:
+    ui_port = settings.proxy_ui_port
     ui = config.ui
     if ui is None:
         return None
@@ -400,29 +325,29 @@ def start_dev_ui_process(
             except Exception:
                 return False
 
-    if _is_port_open(ui.port):
+    if _is_port_open(ui_port):
         logger.info(
-            "Detected process already running on port %s; not starting a new one.",
-            ui.port,
+            f"Detected process already running on port {ui_port}; not starting a new one."
         )
         return None
     # start the ui process
-    env = _ui_env(config)
+    env = _ui_env(config, settings)
     # Transform first 20 lines to replace the default UI port with the main server port
     line_counter = 0
 
     def _transform(line: str) -> str:
         nonlocal line_counter
         if line_counter < 20:
-            line = line.replace(f":{ui.port}", f":{main_port}")
+            line = line.replace(f":{ui_port}", f":{settings.port}")
         line_counter += 1
         return line
 
     return spawn_process(
-        ["pnpm", "run", "dev"],
-        cwd=root / (ui.source.location if ui.source else "."),
+        ["npm", "run", ui.serve_command],
+        cwd=root / (ui.directory),
         env=env,
-        prefix="[pnpm run dev]",
-        color_code="35",  # magenta
+        prefix=f"[npm run {ui.serve_command}]",
+        color_code="35",
         line_transform=_transform,
+        use_tty=False,
     )