ltcai 11.1.0 → 11.4.0

package/latticeai/services/model_runtime/loading.py

@@ -0,0 +1,178 @@
+"""Model identity, engine readiness, and the load entrypoints.
+
+The path from a string a user clicked to a loaded model: resolve engine
+aliases into one canonical identity, make sure the engine that identity needs
+is installed, then hand off to ``latticeai.services.model_loading`` for the
+load itself (blocking and streaming forms) and to
+``latticeai.services.model_engines`` for the post-load smoke test.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, AsyncIterator, Dict, Optional
+
+from latticeai.core.model_resolution import ModelResolution as _ModelResolution
+from latticeai.models.router import OPENAI_COMPATIBLE_PROVIDERS, ensure_mlx_runtime
+from latticeai.services.model_catalog import ENGINE_INSTALLERS, MODEL_ENGINE_ALIASES
+from latticeai.services.model_errors import ModelRuntimeError
+from latticeai.services.model_runtime.engines import (
+    engine_installed,
+    engine_support_status,
+)
+from latticeai.services.model_runtime.state import ModelRuntimeState
+from latticeai.services.model_runtime.status import install_engine
+
+
+def _resolve_model_alias(model_id: str, engine: Optional[str] = None) -> str:
+    raw = model_id.strip()
+    engine_hint = (engine or "").strip().lower()
+    provider: Optional[str] = None
+    model_name = raw
+    if ":" in raw:
+        prefix, rest = raw.split(":", 1)
+        prefix = prefix.strip().lower()
+        if prefix in {"ollama", "vllm", "lmstudio", "llamacpp", "local_mlx", "mlx"}:
+            provider = "local_mlx" if prefix in {"local_mlx", "mlx"} else prefix
+            model_name = rest.strip()
+    provider = provider or ("local_mlx" if engine_hint in {"", "local_mlx", "mlx"} else engine_hint)
+    aliases = MODEL_ENGINE_ALIASES.get(model_name.lower())
+    if not aliases:
+        return raw
+    mapped = aliases.get(provider)
+    if not mapped:
+        return raw
+    return mapped if provider == "local_mlx" else f"{provider}:{mapped}"
+
+
+def normalize_local_model_request(model_id: str, engine: Optional[str] = None) -> str:
+    model_id = _resolve_model_alias(model_id, engine)
+    engine = (engine or "").strip().lower()
+    if engine in {"local_mlx", "mlx"} and model_id.startswith(("local_mlx:", "mlx:")):
+        return model_id.split(":", 1)[1].strip()
+    if engine and engine not in {"local_mlx", "mlx"} and ":" not in model_id:
+        return f"{engine}:{model_id}"
+    return model_id
+
+
+def ensure_engine_ready(engine: str, *, state: ModelRuntimeState) -> Dict[str, Any]:
+    engine = "local_mlx" if engine == "mlx" else engine
+    if engine not in ENGINE_INSTALLERS and engine not in OPENAI_COMPATIBLE_PROVIDERS:
+        raise ModelRuntimeError(status_code=400, detail=f"지원하지 않는 엔진입니다: {engine}")
+    support = engine_support_status(engine)
+    if not support["supported"]:
+        raise ModelRuntimeError(status_code=400, detail=str(support["reason"]))
+
+    if engine_installed(engine):
+        if engine == "local_mlx":
+            ensure_mlx_runtime()
+        return {"engine": engine, "installed": True, "installed_now": False}
+
+    if engine not in ENGINE_INSTALLERS:
+        raise ModelRuntimeError(status_code=400, detail=f"{engine} 엔진 설치 방법이 등록되어 있지 않습니다.")
+
+    result = install_engine(engine, state=state)
+    if result.get("returncode") not in (0, None) or not engine_installed(engine):
+        detail = result.get("stderr") or result.get("stdout") or f"{engine} 설치에 실패했습니다."
+        raise ModelRuntimeError(status_code=500, detail=str(detail)[-2000:])
+
+    if engine == "local_mlx":
+        ensure_mlx_runtime()
+    return {"engine": engine, "installed": True, "installed_now": True, "install": result}
+
+
+def build_model_resolution(
+    input_id: str,
+    engine: Optional[str],
+    *,
+    user_email: Optional[str] = None,
+    display_name: Optional[str] = None,
+) -> _ModelResolution:
+    """피드백 #1/#2 공용 ModelResolution 생성기.
+
+    사용자가 클릭한 input_id + engine 힌트를 받아 모든 단계가 공유할
+    canonical identity를 만든다.
+    """
+    normalized = normalize_local_model_request(input_id, engine)
+    return _ModelResolution.from_request(
+        normalized,
+        engine=engine,
+        user_email=user_email,
+        display_name=display_name or input_id,
+        engine_aliases=MODEL_ENGINE_ALIASES,
+    )
+
+
+_LOCAL_SMOKE_ENGINES = {"local_mlx", "ollama", "vllm", "lmstudio", "llamacpp"}
+
+
+async def _smoke_test_loaded_model(
+    resolution: _ModelResolution,
+    *,
+    api_key_override: Optional[str] = None,
+    state: ModelRuntimeState,
+) -> Dict[str, Any]:
+    # Delegated to model_engines for server decomp
+    # Absolute since v11.3.0: this file moved one level down into the
+    # model_runtime package, so ``.model_engines`` would resolve inside it.
+    from latticeai.services.model_engines import (
+        _smoke_test_loaded_model as _impl_smoke,
+    )
+    return await _impl_smoke(
+        resolution,
+        api_key_override=api_key_override,
+        model_router=state.router,
+    )
+
+
+async def prepare_and_load_model(
+    model_id: str,
+    request: Any,
+    engine: Optional[str] = None,
+    user_email: Optional[str] = None,
+    adapter_path: Optional[str] = None,
+    draft_model_id: Optional[str] = None,
+    allow_download: bool = False,
+    *,
+    state: ModelRuntimeState,
+) -> Dict[str, Any]:
+    from latticeai.services.model_loading import prepare_and_load_model as _impl
+
+    return await _impl(
+        model_id,
+        request,
+        engine=engine,
+        user_email=user_email,
+        adapter_path=adapter_path,
+        draft_model_id=draft_model_id,
+        allow_download=allow_download,
+        runtime_state=state,
+    )
+
+
+def sse_event(event: str, data: Dict[str, Any]) -> str:
+    return f"event: {event}\ndata: {json.dumps(data, ensure_ascii=False)}\n\n"
+
+
+async def prepare_and_load_model_stream(
+    model_id: str,
+    request: Any,
+    engine: Optional[str] = None,
+    user_email: Optional[str] = None,
+    allow_download: bool = False,
+    *,
+    state: ModelRuntimeState,
+) -> AsyncIterator[str]:
+    from latticeai.services.model_loading import (
+        prepare_and_load_model_stream as _impl,
+    )
+
+    async for event in _impl(
+        model_id,
+        request,
+        engine=engine,
+        user_email=user_email,
+        allow_download=allow_download,
+        runtime_state=state,
+    ):
+        yield event

package/latticeai/services/model_runtime/service.py

@@ -0,0 +1,129 @@
+"""The bound runtime service — one application's model operations.
+
+Everything above is a free function taking an explicit ``state``. This is the
+object the composition root holds: it carries that state plus the only piece of
+per-application operational data (the cloud verification cache), so a second
+ASGI app in the same process starts with an empty cache rather than inheriting
+probe results it never ran.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, AsyncIterator, Dict, List, Optional
+
+from latticeai.services.model_runtime.cloud import verify_cloud_models
+from latticeai.services.model_runtime.loading import (
+    prepare_and_load_model,
+    prepare_and_load_model_stream,
+)
+from latticeai.services.model_runtime.state import (
+    ModelRuntimeState,
+    create_model_runtime_state,
+)
+from latticeai.services.model_runtime.status import (
+    engine_status,
+    install_engine,
+    runtime_features,
+)
+
+
+def configure_model_runtime(**deps: Any) -> "ModelRuntimeService":
+    """Compatibility factory returning an isolated, bound runtime service.
+
+    The historical function mutated process-wide module globals.  Keeping the
+    import path while returning a service preserves practical construction
+    compatibility without ambient state or cross-application leakage.
+    """
+
+    return ModelRuntimeService(create_model_runtime_state(**deps))
+
+@dataclass(slots=True)
+class ModelRuntimeService:
+    """Bound model operations for one explicitly configured application.
+
+    All configuration and app-owned callables live on ``state``. Operational
+    verification cache data belongs to this service instance, so creating a
+    second ASGI app cannot inherit credentials, routers, or probe results from
+    the first one.
+    """
+
+    state: ModelRuntimeState
+    _cloud_verify_cache: Dict[str, Dict[str, Any]] = field(default_factory=dict)
+
+    def runtime_features(self) -> Dict[str, Any]:
+        return runtime_features(state=self.state)
+
+    def engine_status(self) -> List[Dict[str, Any]]:
+        return engine_status(
+            state=self.state,
+            cloud_verify_cache=self._cloud_verify_cache,
+        )
+
+    def install_engine(
+        self,
+        engine: str,
+        confirmation_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        return install_engine(
+            engine,
+            confirmation_token=confirmation_token,
+            state=self.state,
+        )
+
+    async def verify_cloud_models(
+        self,
+        force: bool = False,
+        provider_filter: Optional[str] = None,
+    ) -> Dict[str, Dict[str, Any]]:
+        return await verify_cloud_models(
+            force=force,
+            provider_filter=provider_filter,
+            state=self.state,
+            cache=self._cloud_verify_cache,
+        )
+
+    async def prepare_and_load_model(
+        self,
+        model_id: str,
+        request: Any,
+        engine: Optional[str] = None,
+        user_email: Optional[str] = None,
+        adapter_path: Optional[str] = None,
+        draft_model_id: Optional[str] = None,
+        allow_download: bool = False,
+    ) -> Dict[str, Any]:
+        return await prepare_and_load_model(
+            model_id,
+            request,
+            engine=engine,
+            user_email=user_email,
+            adapter_path=adapter_path,
+            draft_model_id=draft_model_id,
+            allow_download=allow_download,
+            state=self.state,
+        )
+
+    async def prepare_and_load_model_stream(
+        self,
+        model_id: str,
+        request: Any,
+        engine: Optional[str] = None,
+        user_email: Optional[str] = None,
+        allow_download: bool = False,
+    ) -> AsyncIterator[str]:
+        async for event in prepare_and_load_model_stream(
+            model_id,
+            request,
+            engine=engine,
+            user_email=user_email,
+            allow_download=allow_download,
+            state=self.state,
+        ):
+            yield event
+
+
+def build_model_runtime(**deps: Any) -> ModelRuntimeService:
+    """Build the application's isolated model runtime service."""
+
+    return ModelRuntimeService(create_model_runtime_state(**deps))

package/latticeai/services/model_runtime/state.py

@@ -0,0 +1,131 @@
+"""The immutable dependency set one model runtime is configured with.
+
+``ModelRuntimeState`` replaced the process-wide module ``STATE`` object: every
+value the runtime needs — router, mode, paths, download/auth policy, the
+app-owned callables — is passed in explicitly and never mutated afterwards, so
+a second ASGI application in the same interpreter cannot inherit the first
+one's credentials or configuration.
+
+Also home to the two consent gates (:func:`_download_block`,
+:func:`_engine_install_block`): presence of a token or a model name never
+authorises network or installer activity on its own.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, fields
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+from latticeai.core.model_compat import (
+    SMOKE_PROMPT as _SMOKE_PROMPT,
+)
+from latticeai.core.model_compat import (
+    friendly_model_runtime_error as _friendly_model_runtime_error,
+)
+from latticeai.core.model_compat import (
+    model_runtime_compatibility as _model_runtime_compatibility,
+)
+from latticeai.services.model_errors import ModelRuntimeError
+
+# ``model_loading._get_model_runtime_deps`` imports these private names from
+# this module to preserve the historical model_runtime wiring surface.
+_MODEL_LOADING_COMPAT_EXPORTS = (
+    _friendly_model_runtime_error,
+    _model_runtime_compatibility,
+    _SMOKE_PROMPT,
+)
+
+
+def _missing_current_user(_request: Any) -> Optional[str]:
+    return None
+
+
+def _missing_user_api_key(_email: Optional[str], _provider: str) -> Optional[str]:
+    return None
+
+
+@dataclass(frozen=True, slots=True)
+class ModelRuntimeState:
+    """Immutable application-owned dependencies for one model runtime.
+
+    Upper-case configuration field names intentionally match the long-standing
+    composition-root vocabulary.  Unlike the former module ``STATE`` object,
+    instances are explicit, immutable, and safe to create more than once in a
+    process (for example in isolated tests or multiple ASGI applications).
+    """
+
+    router: Any = None
+    APP_MODE: str = "local"
+    DEFAULT_HOST: str = "127.0.0.1"
+    DEFAULT_PORT: int = 4825
+    DATA_DIR: Path = field(default_factory=lambda: Path.home() / ".latticeai")
+    BASE_DIR: Path = field(default_factory=Path.cwd)
+    ENABLE_TELEGRAM: bool = False
+    ENABLE_GRAPH: bool = True
+    AUTOLOAD_MODELS: bool = False
+    MODEL_IDLE_UNLOAD_SECONDS: int = 0
+    ALLOW_MODEL_DOWNLOADS: bool = False
+    MODEL_DOWNLOAD_TIMEOUT: int = 300
+    ALLOW_LOCAL_MODELS: bool = True
+    REQUIRE_AUTH: bool = False
+    INVITE_GATE_ENABLED: bool = False
+    ALLOW_PLAINTEXT_API_KEYS: bool = False
+    CORS_ALLOW_NETWORK: bool = False
+    PUBLIC_MODEL: str = "openai:gpt-4o-mini"
+    LOCAL_MODEL: str = "mlx-community/gemma-4-12B-it-4bit"
+    IS_PUBLIC_MODE: bool = False
+    keyring: Any = None
+    get_current_user: Callable[[Any], Optional[str]] = _missing_current_user
+    get_user_api_key: Callable[[Optional[str], str], Optional[str]] = _missing_user_api_key
+
+
+def create_model_runtime_state(**deps: Any) -> ModelRuntimeState:
+    """Create an immutable runtime dependency set with strict key validation."""
+
+    known = {item.name for item in fields(ModelRuntimeState)}
+    unknown = sorted(set(deps) - known)
+    if unknown:
+        raise TypeError(f"unknown model runtime dependencies: {', '.join(unknown)}")
+    return ModelRuntimeState(**deps)
+
+def _download_allowed(
+    allow_download: bool = False, *, state: ModelRuntimeState
+) -> bool:
+    autoload = state.AUTOLOAD_MODELS
+    configured = state.ALLOW_MODEL_DOWNLOADS
+    return bool(allow_download) or bool(configured) or bool(autoload)
+
+
+def _download_block(provider: str, model_name: str) -> None:
+    raise ModelRuntimeError(
+        status_code=409,
+        detail={
+            "status": "unavailable",
+            "capability": "model_download",
+            "provider": provider,
+            "model": model_name,
+            "reason": (
+                "Model files are not present locally. Lattice AI does not start "
+                "outbound model downloads by default, and token/model presence "
+                "alone never authorizes network activity."
+            ),
+            "action": "Use the explicit pull/prepare flow with download consent, or set LATTICEAI_ALLOW_MODEL_DOWNLOADS=true.",
+        },
+    )
+
+
+def _engine_install_block(engine: str) -> None:
+    raise ModelRuntimeError(
+        status_code=409,
+        detail={
+            "status": "unavailable",
+            "capability": "engine_install",
+            "engine": engine,
+            "reason": (
+                "The requested local runtime is not installed. Lattice AI does not "
+                "run package-manager or installer commands from Model Load by default."
+            ),
+            "action": "Install the runtime explicitly from Library/System setup, or enable explicit download/install consent for this request.",
+        },
+    )

package/latticeai/services/model_runtime/status.py

@@ -0,0 +1,255 @@
+"""What this machine can run: the engine/model status payload.
+
+:func:`engine_status` is the single answer the Library screen renders — every
+engine (local, local-server, cloud), whether it is installed, whether its
+install is even supported here, and which catalogue models are already pulled.
+:func:`runtime_features` is the same idea for the application itself, and
+:func:`install_engine` is the one write this module owns.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from latticeai.models.router import HF_MODELS_ROOT
+from latticeai.services.model_catalog import (
+    ENGINE_INSTALLERS,
+    ENGINE_MODEL_CATALOG,
+    filter_lower_family_versions,
+)
+from latticeai.services.model_engines import (
+    install_engine as _install_engine,
+)
+from latticeai.services.model_runtime.download import hf_model_ready
+from latticeai.services.model_runtime.engines import (
+    _safe_engine_install_plan,
+    engine_installed,
+    engine_support_status,
+    get_lmstudio_models,
+    get_ollama_pulled_models,
+)
+from latticeai.services.model_runtime.state import ModelRuntimeState
+
+
+def engine_status(
+    *,
+    state: ModelRuntimeState,
+    cloud_verify_cache: Optional[Dict[str, Dict[str, Any]]] = None,
+) -> List[Dict]:
+    r = state.router
+    verify_cache = cloud_verify_cache or {}
+    cloud_models = r.detected_cloud_models() if r else []
+    cloud_by_provider: Dict[str, List[Dict[str, Any]]] = {}
+    for model in cloud_models:
+        cloud_by_provider.setdefault(model["provider"], []).append(model)
+
+    ollama_installed = engine_installed("ollama")
+    pulled = get_ollama_pulled_models() if ollama_installed else set()
+    ollama_models = []
+    for m in ENGINE_MODEL_CATALOG["ollama"]:
+        pull_name = m["id"].removeprefix("ollama:")
+        ollama_models.append({**m, "pulled": pull_name in pulled})
+    ollama_models = filter_lower_family_versions(ollama_models)
+
+    HF_MODELS_ROOT.mkdir(parents=True, exist_ok=True)
+    mlx_models = []
+    for m in ENGINE_MODEL_CATALOG.get("local_mlx", []):
+        repo_id = m["id"]
+        mlx_models.append({**m, "pulled": hf_model_ready(repo_id, "local_mlx")})
+    mlx_models = filter_lower_family_versions(mlx_models)
+
+    vllm_models = []
+    for m in ENGINE_MODEL_CATALOG.get("vllm", []):
+        repo_id = m["id"].removeprefix("vllm:")
+        vllm_models.append({**m, "pulled": hf_model_ready(repo_id, "vllm")})
+    vllm_models = filter_lower_family_versions(vllm_models)
+
+    lmstudio_models = []
+    downloaded_lmstudio = get_lmstudio_models()
+    downloaded_by_key: Dict[str, Dict[str, Any]] = {}
+    for item in downloaded_lmstudio:
+        key = str(item.get("key") or "").strip()
+        if not key:
+            continue
+        downloaded_by_key[key] = item
+        loaded_instances = item.get("loaded_instances") or []
+        lmstudio_models.append({
+            "id": f"lmstudio:{key}",
+            "name": item.get("display_name") or f"LM Studio · {key}",
+            "family": item.get("architecture") or item.get("publisher") or "LM Studio",
+            "tag": "loaded-server-model" if loaded_instances else "downloaded",
+            "size": item.get("params_string") or item.get("format") or "LM Studio",
+            "pullable": True,
+            "pulled": True,
+        })
+
+    if not lmstudio_models:
+        for m in ENGINE_MODEL_CATALOG.get("lmstudio", []):
+            lmstudio_models.append({**m, "pulled": False})
+    else:
+        known_ids = {item["id"] for item in lmstudio_models}
+        for m in ENGINE_MODEL_CATALOG.get("lmstudio", []):
+            repo_id = m["id"].removeprefix("lmstudio:")
+            if f"lmstudio:{repo_id}" not in known_ids and repo_id not in downloaded_by_key:
+                lmstudio_models.append({**m, "pulled": False})
+    lmstudio_models = filter_lower_family_versions(lmstudio_models)
+
+    llamacpp_models = []
+    for m in ENGINE_MODEL_CATALOG.get("llamacpp", []):
+        repo_id = m["id"].removeprefix("llamacpp:")
+        llamacpp_models.append({**m, "pulled": hf_model_ready(repo_id, "llamacpp")})
+    llamacpp_models = filter_lower_family_versions(llamacpp_models)
+
+    local_server_specs: List[Dict[str, Any]] = [
+        {
+            "id": "vllm",
+            "name": "vLLM",
+            "description": "vLLM OpenAI 호환 서버(예: http://localhost:8000/v1)에 연결합니다.",
+            "requires": "VLLM_BASE_URL",
+            "note": engine_support_status("vllm").get("reason"),
+        },
+        {
+            "id": "lmstudio",
+            "name": "LM Studio",
+            "description": "LM Studio 로컬 OpenAI 호환 서버에 연결합니다.",
+            "requires": "LMSTUDIO_BASE_URL",
+            "note": (
+                "다운로드된 모델은 자동 감지하고, 선택 시 필요하면 다운로드 후 바로 로드합니다."
+                if downloaded_lmstudio else
+                "LM Studio 설치 후 모델을 선택하면 Local Server 시작, 다운로드, 로드를 자동으로 진행합니다."
+            ),
+            "server_ready": bool(downloaded_lmstudio),
+        },
+        {
+            "id": "llamacpp",
+            "name": "llama.cpp",
+            "description": "llama.cpp 서버(OpenAI 호환 /v1)에 연결합니다.",
+            "requires": "LLAMACPP_BASE_URL",
+        },
+    ]
+
+    engines = [
+        {
+            "id": "local_mlx",
+            "name": "MLX",
+            "kind": "local",
+            "description": "Apple Silicon GPU에서 MLX-VLM 모델을 직접 실행하고, Gemma 4는 필요 시 MLX-LM 텍스트 경로로 재시도합니다.",
+            "installed": engine_installed("local_mlx"),
+            "installable": True,
+            "install_label": ENGINE_INSTALLERS["local_mlx"]["label"],
+            "install_plan": _safe_engine_install_plan("local_mlx", base_dir=state.BASE_DIR),
+            "models": mlx_models,
+        },
+        {
+            "id": "ollama",
+            "name": "Ollama",
+            "kind": "local-server",
+            "description": "Ollama 로컬 서버를 OpenAI 호환 엔진처럼 사용합니다.",
+            "installed": ollama_installed,
+            "installable": True,
+            "install_label": ENGINE_INSTALLERS["ollama"]["label"],
+            "install_plan": _safe_engine_install_plan("ollama", base_dir=state.BASE_DIR),
+            "models": ollama_models,
+        },
+    ]
+    for spec in local_server_specs:
+        support = engine_support_status(spec["id"])
+        engines.append({
+            "id": spec["id"],
+            "name": spec["name"],
+            "kind": "local-server",
+            "description": spec["description"],
+            "installed": engine_installed(spec["id"]),
+            "supported": support["supported"],
+            "support_reason": support["reason"],
+            "installable": support["supported"] and spec["id"] in ENGINE_INSTALLERS,
+            "install_label": ENGINE_INSTALLERS.get(spec["id"], {}).get("label"),
+            "install_plan": (
+                _safe_engine_install_plan(spec["id"], base_dir=state.BASE_DIR)
+                if spec["id"] in ENGINE_INSTALLERS
+                else None
+            ),
+            "requires": spec["requires"],
+            "models": (
+                vllm_models if spec["id"] == "vllm"
+                else lmstudio_models if spec["id"] == "lmstudio"
+                else llamacpp_models if spec["id"] == "llamacpp"
+                else ENGINE_MODEL_CATALOG.get(spec["id"], [])
+            ),
+            "note": spec.get("note") or support["reason"] or f"{spec['requires']} 설정 시 활성화됩니다.",
+            "server_ready": spec.get("server_ready"),
+        })
+    for provider in ["openai", "openrouter", "groq", "together", "xai"]:
+        env_key = next((item.get("requires") for item in cloud_by_provider.get(provider, []) if item.get("requires")), None)
+        provider_models = []
+        for model in cloud_by_provider.get(provider, []):
+            cache = verify_cache.get(str(model.get("id") or ""))
+            provider_models.append({
+                **model,
+                "verified": cache.get("ok") if cache else None,
+                "verify_reason": cache.get("reason") if cache else None,
+            })
+        engines.append({
+            "id": provider,
+            "name": provider.title(),
+            "kind": "cloud",
+            "description": "OpenAI 호환 Chat Completions API로 cloud LLM을 실행합니다.",
+            "installed": engine_installed(provider),
+            "installable": True,
+            "install_label": ENGINE_INSTALLERS[provider]["label"],
+            "install_plan": _safe_engine_install_plan(provider, base_dir=state.BASE_DIR),
+            "requires": env_key,
+            "models": provider_models,
+        })
+    return engines
+
+def runtime_features(*, state: ModelRuntimeState) -> Dict:
+    s = state
+    r = s.router
+    return {
+        "mode": s.APP_MODE,
+        "public": s.IS_PUBLIC_MODE,
+        "host": s.DEFAULT_HOST,
+        "port": s.DEFAULT_PORT,
+        "data_dir": str(s.DATA_DIR),
+        "telegram_enabled": s.ENABLE_TELEGRAM,
+        "graph_enabled": s.ENABLE_GRAPH,
+        "autoload_models": s.AUTOLOAD_MODELS,
+        "model_idle_unload_seconds": s.MODEL_IDLE_UNLOAD_SECONDS,
+        "allow_model_downloads": s.ALLOW_MODEL_DOWNLOADS,
+        "model_download_timeout": s.MODEL_DOWNLOAD_TIMEOUT,
+        "model_memory_policy": r.model_memory_policy() if r else None,
+        "allow_local_models": s.ALLOW_LOCAL_MODELS,
+        "security": {
+            "host": s.DEFAULT_HOST,
+            "require_auth": s.REQUIRE_AUTH,
+            "invite_gate_enabled": s.INVITE_GATE_ENABLED,
+            "keyring_available": s.keyring is not None,
+            "plaintext_api_keys_allowed": s.ALLOW_PLAINTEXT_API_KEYS,
+            "cors_allow_network": s.CORS_ALLOW_NETWORK,
+        },
+        "default_model": s.PUBLIC_MODEL if s.IS_PUBLIC_MODE else s.LOCAL_MODEL,
+        "local_only_features": {
+            "mlx": s.ALLOW_LOCAL_MODELS and not s.IS_PUBLIC_MODE,
+            "telegram_bridge": s.ENABLE_TELEGRAM,
+            "desktop_chrome_bridge": not s.IS_PUBLIC_MODE,
+            "computer_use_bridge": not s.IS_PUBLIC_MODE,
+        },
+        "public_features": {
+            "web_ui": True,
+            "openai_compatible_models": True,
+            "persistent_data_dir": str(s.DATA_DIR),
+        },
+    }
+
+def install_engine(
+    engine: str,
+    confirmation_token: Optional[str] = None,
+    *,
+    state: ModelRuntimeState,
+) -> Dict:
+    return _install_engine(
+        engine,
+        confirmation_token=confirmation_token,
+        base_dir=state.BASE_DIR,
+    )