ltcai 11.5.2 → 11.7.0

package/latticeai/api/models.py

@@ -1,8 +1,16 @@
-"""Model / engine API router.
+"""Model / engine API router — the MLX lifecycle this process owns.
 
-Extracted from ``server_app.py`` in v1.3.0. Paths and schemas unchanged:
-``/models*``, ``/engines*`` (install/verify-cloud/pull-model/prepare-model[/stream]),
-``/setup/set-api-key``.
+Extracted from ``server_app.py`` in v1.3.0 with the whole ``/models*`` +
+``/engines*`` + ``/setup/set-api-key`` surface. v11.6.0 kept the eight routes
+that are *this interpreter's* business — loading, switching and unloading MLX
+models, and the resolve → download-if-consented → load → smoke prepare flow —
+and moved the rest to ``lattice-host``: engine installation and cloud-key
+verification are host operations, ``/setup/set-api-key`` is account state, and
+the two catalogue reads (``/models/compat-profiles``, ``/models/recommendations``)
+are product views.
+
+The download itself stays because it is ``huggingface_hub`` / ``ollama``
+running here (v11.6.0 gateway integration §4a).
 
 Mirrors the established router-factory convention: the heavy provider/runtime
 helpers are injected as bound service callables. This module owns the sole
@@ -66,15 +74,6 @@ class LoadModelRequest(BaseModel):
     allow_download: bool = False
 
 
-class InstallEngineRequest(BaseModel):
-    engine: str
-    confirmation_token: Optional[str] = None
-
-
-class SetApiKeyRequest(BaseModel):
-    provider: str
-    key: str
-    user_email: Optional[str] = None
 
 
 class PullModelRequest(BaseModel):
@@ -89,21 +88,12 @@ class PrepareModelRequest(BaseModel):
     allow_download: bool = False
 
 
-class VerifyCloudRequest(BaseModel):
-    force: bool = False
-    provider: Optional[str] = None
-
 
 def create_models_router(
     *,
     model_router: Any,
     require_user: Callable[[Request], str],
     require_admin: Callable[[Request], tuple],
-    get_current_user: Callable[[Request], Optional[str]],
-    load_users: Callable[[], Dict],
-    get_user_role: Callable[..., str],
-    install_engine: Callable[..., Dict],
-    verify_cloud_models: Callable[..., Any],
     normalize_local_model_request: Callable[..., str],
     download_hf_model: Callable[..., Dict],
     prepare_and_load_model: Callable[..., Any],
@@ -114,10 +104,8 @@ def create_models_router(
     engine_status: Callable[[], List[Dict]],
     filter_lower_family_versions: Callable[[List[Dict]], List[Dict]],
     list_compat_profiles: Callable[[], Any],
-    set_user_api_key: Callable[..., None],
     engine_model_catalog: Dict,
     model_engine_aliases: Dict,
-    cloud_verify_ttl_seconds: int,
     is_public_mode: bool,
     allow_local_models: bool,
     require_auth: bool,
@@ -127,7 +115,6 @@ def create_models_router(
     _router = model_router
     ENGINE_MODEL_CATALOG = engine_model_catalog
     MODEL_ENGINE_ALIASES = model_engine_aliases
-    CLOUD_VERIFY_TTL_SECONDS = cloud_verify_ttl_seconds
     IS_PUBLIC_MODE = is_public_mode
     ALLOW_LOCAL_MODELS = allow_local_models
     REQUIRE_AUTH = require_auth
@@ -302,29 +289,6 @@ def create_models_router(
 
     # ── Engines ───────────────────────────────────────────────────────────
 
-    @router.post("/engines/install")
-    async def engines_install(req: InstallEngineRequest, request: Request):
-        _authorize_model_admin(request)
-        try:
-            # `install_engine` shells out with a 900s timeout. On the event loop
-            # that is a fifteen-minute freeze of the entire server — no chat, no
-            # status, no UI — for one admin installing an engine.
-            if req.confirmation_token:
-                return await asyncio.to_thread(
-                    install_engine, req.engine, confirmation_token=req.confirmation_token
-                )
-            return await asyncio.to_thread(install_engine, req.engine)
-        except ModelRuntimeError as exc:
-            _raise_model_http(exc)
-
-    @router.post("/engines/verify-cloud")
-    async def engines_verify_cloud(req: VerifyCloudRequest, request: Request):
-        _authorize_model_admin(request)
-        try:
-            results = await verify_cloud_models(force=req.force, provider_filter=req.provider)
-        except ModelRuntimeError as exc:
-            _raise_model_http(exc)
-        return {"verified": results, "ttl_seconds": CLOUD_VERIFY_TTL_SECONDS}
 
     @router.post("/engines/pull-model")
     async def pull_ollama_model(req: PullModelRequest, request: Request):
@@ -452,22 +416,6 @@ def create_models_router(
             headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
         )
 
-    @router.post("/setup/set-api-key")
-    async def set_api_key(req: SetApiKeyRequest, request: Request):
-        from latticeai.models.router import OPENAI_COMPATIBLE_PROVIDERS
-        config = OPENAI_COMPATIBLE_PROVIDERS.get(req.provider)
-        if not config:
-            raise http_error(400, "models.unknown_provider", resolve_language(request))
-        if not req.key.strip():
-            raise http_error(400, "models.api_key_empty", resolve_language(request))
-        current_user = require_user(request)
-        if REQUIRE_AUTH and req.user_email and _normalized_identity(req.user_email) != _normalized_identity(current_user):
-            raise http_error(403, "models.other_user_api_key", resolve_language(request))
-        target_email = str(_effective_email(current_user, req.user_email) or "").strip()
-        if not target_email:
-            raise http_error(400, "models.sign_in_required", resolve_language(request))
-        set_user_api_key(target_email, req.provider, req.key.strip())
-        return {"ok": True, "provider": req.provider, "user_email": target_email, "scope": "user"}
 
     # ── Models ────────────────────────────────────────────────────────────
 
@@ -503,10 +451,6 @@ def create_models_router(
             },
         }
 
-    @router.get("/models/compat-profiles")
-    async def list_model_compat_profiles(request: Request):
-        require_user(request)
-        return {"profiles": _list_compat_profiles()}
 
     @router.post("/models/load")
     async def load_model(req: LoadModelRequest, request: Request):
@@ -562,24 +506,5 @@ def create_models_router(
         _router.unload_all()
         return {"status": "ok", "unloaded": unloaded}
 
-    @router.get("/models/recommendations")
-    async def model_recommendations(request: Request, engine: str = "local_mlx"):
-        """Hardware-aware tri-state model recommendation for this machine.
-
-        5.2.0: now includes rich capability fields (hf_repo_id, verification,
-        hardware, load_strategy, license, safety_notes) from the structured registry.
-        """
-        require_user(request)
-        from latticeai.services.model_recommendation import recommend_catalog
-        from latticeai.setup.auto_setup import probe as auto_setup_probe
-
-        profile = await asyncio.to_thread(lambda: auto_setup_probe().to_json())
-        catalog = recommend_catalog(profile, engine=engine)
-        try:
-            from latticeai.services.model_catalog import get_verified_models
-            reg_meta = {"version": "5.2.0", "verified_total": len(get_verified_models())}
-        except Exception:
-            reg_meta = {"version": "5.2.0"}
-        return {"profile": profile, "recommendations": catalog, "registry": reg_meta}
 
     return router

package/latticeai/api/search.py

@@ -1,89 +1,25 @@
-"""v3 knowledge graph, vector, and hybrid search API contracts."""
+"""The embedder report — what this worker will turn text into.
+
+v3 shipped this module as the knowledge-graph / vector / hybrid search API: 15
+routes over the store, the ANN index and the fusion ranker. v11.6.0 moved
+retrieval into ``lattice-retrieval`` and the index write door into
+``lattice-jobs``, and what stays in Python is the half that is a fact about
+*this process*: which embedding provider resolved, at what width, and whether
+it is the one that was asked for.
+
+``GET /api/embeddings/status`` therefore reports the **embedder**, not the
+index. Index completeness is a native jobs route now, and reporting it from
+here would have meant re-opening a store the worker no longer holds.
+"""
 
 from __future__ import annotations
 
 from typing import Any, Callable, Dict, NoReturn, Optional
 
 from fastapi import APIRouter, HTTPException, Request
-from pydantic import BaseModel, Field
 
 from latticeai.core.embedding_providers import embedding_provider_profiles
-from latticeai.services.search_service import DEFAULT_HYBRID_WEIGHTS, SearchService
-
-
-class SearchRequest(BaseModel):
-    query: str = Field(..., min_length=1)
-    limit: int = 30
-
-
-class VectorSearchRequest(SearchRequest):
-    min_score: float = 0.0
-
-
-class HybridSearchRequest(SearchRequest):
-    keyword_limit: int = 30
-    vector_limit: int = 30
-    graph_limit: int = 30
-    weights: Optional[Dict[str, float]] = None
-    #: Opt in to scoring this text query against the *image* index too
-    #: (v11.2.0). Only possible when a shared-space vision model is
-    #: configured; when it is not, the response says so instead of quietly
-    #: returning the text-only ranking as if fusion had happened.
-    image_fusion: bool = False
-
-
-class GraphSearchRequest(SearchRequest):
-    #: How far to walk out from the directly-matching nodes. The service
-    #: clamps this to 0–3; 0 means "matches only, no expansion".
-    expand_depth: int = 1
-
-
-class GraphNodeRequest(BaseModel):
-    node_id: str = Field(..., min_length=1)
-    include_neighbors: bool = True
-    depth: int = 1
-    limit: int = 100
-
-
-class RelationshipSearchRequest(BaseModel):
-    query: str = ""
-    node_id: str = ""
-    relationship_type: str = ""
-    limit: int = 30
-
-
-class IndexRebuildRequest(BaseModel):
-    full: bool = False
-    include_nodes: bool = True
-    include_chunks: bool = True
-
-
-class _ScopedSearchService:
-    """Injects the caller's workspace scope into every search call —
-    enforcement lives at this one chokepoint, not in each handler."""
-
-    _SCOPED = {
-        "keyword_search",
-        "vector_search",
-        "graph_search",
-        "hybrid_search",
-        "graph",
-        "node",
-        "relationships",
-    }
-
-    def __init__(self, service: SearchService, allowed):
-        self._service = service
-        self._allowed = allowed
-
-    def __getattr__(self, name):
-        attr = getattr(self._service, name)
-        if name in self._SCOPED:
-            def scoped(*args, **kwargs):
-                kwargs.setdefault("allowed_workspaces", self._allowed)
-                return attr(*args, **kwargs)
-            return scoped
-        return attr
+from latticeai.services.search_service import SearchService
 
 
 def create_search_router(
@@ -91,188 +27,14 @@ def create_search_router(
     service: SearchService,
     require_user: Callable[[Request], str],
     embedding_info: Optional[Callable[[], Dict[str, Any]]] = None,
-    allowed_workspaces_for: Optional[Callable[[Optional[str]], Any]] = None,
 ) -> APIRouter:
     router = APIRouter()
 
-    def _guarded(request: Request) -> "_ScopedSearchService":
-        user = require_user(request)
-        allowed = None
-        if allowed_workspaces_for is not None and user:
-            allowed = allowed_workspaces_for(user)
-        return _ScopedSearchService(service, allowed)
-
-    def _raise_graph_error(exc: Exception) -> NoReturn:
-        # NoReturn, not None: every handler ends with this in its except
+    def _raise_embedder_error(exc: Exception) -> NoReturn:
+        # NoReturn, not None: both handlers end with this in their except
         # branch, and without it each one reads as a missing return.
         raise HTTPException(status_code=404, detail=str(exc)) from exc
 
-    @router.post("/api/search/hybrid")
-    async def hybrid_search(req: HybridSearchRequest, request: Request) -> Dict[str, Any]:
-        try:
-            return _guarded(request).hybrid_search(
-                req.query,
-                limit=req.limit,
-                keyword_limit=req.keyword_limit,
-                vector_limit=req.vector_limit,
-                graph_limit=req.graph_limit,
-                weights=req.weights or DEFAULT_HYBRID_WEIGHTS,
-                image_fusion=req.image_fusion,
-            )
-        except ValueError as exc:
-            _raise_graph_error(exc)
-
-    @router.get("/api/search/hybrid")
-    async def hybrid_search_get(
-        q: str, request: Request, limit: int = 30, image_fusion: bool = False,
-    ) -> Dict[str, Any]:
-        try:
-            return _guarded(request).hybrid_search(q, limit=limit, image_fusion=image_fusion)
-        except ValueError as exc:
-            _raise_graph_error(exc)
-
-    @router.get("/api/search/image-query")
-    async def image_query_status(request: Request) -> Dict[str, Any]:
-        """Whether a typed question can reach the image index on this install."""
-        require_user(request)
-        return service.image_query_status()
-
-    @router.post("/api/search/keyword")
-    async def keyword_search(req: SearchRequest, request: Request) -> Dict[str, Any]:
-        try:
-            return _guarded(request).keyword_search(req.query, limit=req.limit)
-        except ValueError as exc:
-            _raise_graph_error(exc)
-
-    @router.get("/api/search/keyword")
-    async def keyword_search_get(q: str, request: Request, limit: int = 30) -> Dict[str, Any]:
-        try:
-            return _guarded(request).keyword_search(q, limit=limit)
-        except ValueError as exc:
-            _raise_graph_error(exc)
-
-    @router.post("/api/search/vector")
-    async def vector_search(req: VectorSearchRequest, request: Request) -> Dict[str, Any]:
-        try:
-            return _guarded(request).vector_search(req.query, limit=req.limit, min_score=req.min_score)
-        except ValueError as exc:
-            _raise_graph_error(exc)
-
-    @router.get("/api/search/vector")
-    async def vector_search_get(
-        q: str,
-        request: Request,
-        limit: int = 30,
-        min_score: float = 0.0,
-    ) -> Dict[str, Any]:
-        try:
-            return _guarded(request).vector_search(q, limit=limit, min_score=min_score)
-        except ValueError as exc:
-            _raise_graph_error(exc)
-
-    @router.post("/api/search/graph")
-    async def graph_search(req: GraphSearchRequest, request: Request) -> Dict[str, Any]:
-        """Relationship-aware search: direct matches plus what they connect to.
-
-        The third retrieval channel. It was in ``_ScopedSearchService._SCOPED``
-        from the start — so the workspace guard was ready for it — but no
-        handler ever called it, which made the allow-list entry the only
-        evidence the channel was supposed to be reachable at all.
-        """
-        try:
-            return _guarded(request).graph_search(
-                req.query,
-                limit=req.limit,
-                expand_depth=req.expand_depth,
-            )
-        except ValueError as exc:
-            _raise_graph_error(exc)
-
-    @router.get("/api/graph")
-    async def graph(request: Request, limit: int = 300) -> Dict[str, Any]:
-        try:
-            return _guarded(request).graph(limit=limit)
-        except ValueError as exc:
-            _raise_graph_error(exc)
-
-    @router.get("/api/graph/node")
-    async def graph_node(
-        node_id: str,
-        request: Request,
-        include_neighbors: bool = True,
-        depth: int = 1,
-        limit: int = 100,
-    ) -> Dict[str, Any]:
-        try:
-            return _guarded(request).node(
-                node_id,
-                include_neighbors=include_neighbors,
-                depth=depth,
-                limit=limit,
-            )
-        except ValueError as exc:
-            raise HTTPException(status_code=404, detail=str(exc)) from exc
-
-    @router.post("/api/graph/node")
-    async def graph_node_post(req: GraphNodeRequest, request: Request) -> Dict[str, Any]:
-        try:
-            return _guarded(request).node(
-                req.node_id,
-                include_neighbors=req.include_neighbors,
-                depth=req.depth,
-                limit=req.limit,
-            )
-        except ValueError as exc:
-            raise HTTPException(status_code=404, detail=str(exc)) from exc
-
-    @router.get("/api/graph/relationship")
-    async def graph_relationship(
-        request: Request,
-        q: str = "",
-        node_id: str = "",
-        relationship_type: str = "",
-        limit: int = 30,
-    ) -> Dict[str, Any]:
-        try:
-            return _guarded(request).relationships(
-                query=q,
-                node_id=node_id,
-                relationship_type=relationship_type,
-                limit=limit,
-            )
-        except ValueError as exc:
-            _raise_graph_error(exc)
-
-    @router.post("/api/graph/relationship")
-    async def graph_relationship_post(req: RelationshipSearchRequest, request: Request) -> Dict[str, Any]:
-        try:
-            return _guarded(request).relationships(
-                query=req.query,
-                node_id=req.node_id,
-                relationship_type=req.relationship_type,
-                limit=req.limit,
-            )
-        except ValueError as exc:
-            _raise_graph_error(exc)
-
-    @router.get("/api/index/status")
-    async def index_status(request: Request) -> Dict[str, Any]:
-        try:
-            return _guarded(request).index_status()
-        except ValueError as exc:
-            _raise_graph_error(exc)
-
-    @router.post("/api/index/rebuild")
-    async def index_rebuild(req: IndexRebuildRequest, request: Request) -> Dict[str, Any]:
-        try:
-            return _guarded(request).rebuild_index(
-                full=req.full,
-                include_nodes=req.include_nodes,
-                include_chunks=req.include_chunks,
-            )
-        except ValueError as exc:
-            _raise_graph_error(exc)
-
     @router.get("/api/embeddings/status")
     async def embeddings_status(request: Request, refresh: bool = False) -> Dict[str, Any]:
         require_user(request)
@@ -280,7 +42,7 @@ def create_search_router(
         try:
             return service.embeddings_status(resolved=resolved, refresh=refresh)
         except ValueError as exc:
-            _raise_graph_error(exc)
+            _raise_embedder_error(exc)
 
     @router.get("/api/embeddings/providers")
     async def embeddings_providers(request: Request) -> Dict[str, Any]: