ltcai 11.5.0 → 11.5.2

package/latticeai/services/hybrid_policy.py

@@ -12,16 +12,13 @@ Persisted under the data dir, scoped like NetworkBoundaryService
 
 from __future__ import annotations
 
-import json
-import threading
-from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Set
+from typing import Any, Dict, List, Optional, Set
 
-from latticeai.core.io_utils import atomic_write_json
 from latticeai.core.network_boundary import (
     HARD_BLOCK_METADATA_FLAGS,
     HARD_BLOCK_NODE_TYPES,
 )
+from latticeai.services.mode_store import JsonBackedModeService
 
 DEFAULT_BLOCKED_TYPES: List[str] = []
 DEFAULT_BLOCKED_FLAGS: List[str] = sorted(HARD_BLOCK_METADATA_FLAGS)
@@ -39,51 +36,15 @@ def _default_policy() -> Dict[str, Any]:
     }
 
 
-class HybridPolicyService:
+class HybridPolicyService(JsonBackedModeService[Dict[str, Any]]):
     """Load / save hybrid cloud policy."""
 
-    def __init__(
-        self,
-        *,
-        data_dir: Path,
-        audit: Optional[Callable[..., None]] = None,
-    ) -> None:
-        self._path = Path(data_dir) / "hybrid_policy.json"
-        self._audit = audit or (lambda *a, **kw: None)
-        self._lock = threading.Lock()
-
-    def rebind_data_dir(self, data_dir: Path) -> None:
-        with self._lock:
-            self._path = Path(data_dir) / "hybrid_policy.json"
+    FILENAME = "hybrid_policy.json"
 
-    def rebind_audit(self, audit: Callable[..., None]) -> None:
-        with self._lock:
-            self._audit = audit
+    def _default_entry(self) -> Any:
+        return _default_policy()
 
-    def _read(self) -> Dict[str, Any]:
-        base = {
-            "default": _default_policy(),
-            "users": {},
-            "workspaces": {},
-        }
-        if not self._path.exists():
-            return base
-        try:
-            data = json.loads(self._path.read_text(encoding="utf-8"))
-        except Exception:
-            return base
-        if not isinstance(data, dict):
-            return base
-        data.setdefault("default", _default_policy())
-        data.setdefault("users", {})
-        data.setdefault("workspaces", {})
-        return data
-
-    def _write(self, data: Dict[str, Any]) -> None:
-        self._path.parent.mkdir(parents=True, exist_ok=True)
-        atomic_write_json(self._path, data)
-
-    def _resolve_raw(
+    def _resolve_from(
         self,
         data: Dict[str, Any],
         *,
@@ -116,16 +77,6 @@ class HybridPolicyService:
             policy["min_extraction_confidence"] = 0.55
         return policy
 
-    def resolve(
-        self,
-        *,
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        with self._lock:
-            data = self._read()
-        return self._resolve_raw(data, user_email=user_email, workspace_id=workspace_id)
-
     def set_policy(
         self,
         patch: Dict[str, Any],
@@ -144,7 +95,7 @@ class HybridPolicyService:
         clean = {k: v for k, v in (patch or {}).items() if k in allowed}
         with self._lock:
             data = self._read()
-            previous = self._resolve_raw(
+            previous = self._resolve_from(
                 data, user_email=user_email, workspace_id=workspace_id
             )
             if workspace_id:

package/latticeai/services/mode_store.py

@@ -0,0 +1,132 @@
+"""The shared storage half of the scoped preference dials.
+
+``PermissionModeService``, ``NetworkBoundaryService`` and ``HybridPolicyService``
+are three different policies over one identical store: a JSON file under the
+data dir holding ``{"default": …, "users": {…}, "workspaces": {…}}``, guarded by
+a lock, rebindable after lazy construction, and read defensively enough that a
+truncated or hand-edited file degrades to defaults instead of taking the app
+down.
+
+That half was written three times, character for character. Three copies of a
+"corrupt file falls back to defaults" rule is three chances for one of them to
+grow an exception path the others do not have — and the symptom would be one
+dial silently forgetting a user's choice while the other two remember. The
+storage lives here once; each service supplies only what actually differs:
+the file name, what an unset ``default`` means, and how a scope resolves.
+
+Deliberately *not* shared: ``set_mode``/``set_policy``. They look similar but
+their write shapes differ (a scalar mode replaces, a policy patch merges) and
+their audit events carry different payloads, so folding them together would
+mean a parameterised method with more branches than the two bodies it replaced.
+"""
+
+from __future__ import annotations
+
+import json
+import threading
+from pathlib import Path
+from typing import Any, Callable, ClassVar, Dict, Generic, Optional, TypeVar
+
+from latticeai.core.io_utils import atomic_write_json
+
+#: What ``resolve`` hands back — an enum member for the mode dials, a plain
+#: dict for the policy service.
+ResolvedT = TypeVar("ResolvedT")
+
+__all__ = ["JsonBackedModeService"]
+
+
+class JsonBackedModeService(Generic[ResolvedT]):
+    """A lock-guarded, scope-aware JSON preference file.
+
+    Subclasses set :attr:`FILENAME` and implement :meth:`_default_entry` and
+    :meth:`_resolve_from`.
+    """
+
+    #: File name under the data dir. Subclasses must set this.
+    FILENAME: ClassVar[str] = ""
+
+    def __init__(
+        self,
+        *,
+        data_dir: Path,
+        audit: Optional[Callable[..., None]] = None,
+    ) -> None:
+        self._path = Path(data_dir) / self.FILENAME
+        self._audit = audit or (lambda *a, **kw: None)
+        self._lock = threading.Lock()
+
+    # ── rebinding ────────────────────────────────────────────────────────────
+    def rebind_data_dir(self, data_dir: Path) -> None:
+        """Point the store at the app's real data dir.
+
+        The wiring may instantiate a service lazily before routers know the
+        configured data dir; rebinding keeps one file of record instead of
+        stranding writes under the fallback path.
+        """
+        with self._lock:
+            self._path = Path(data_dir) / self.FILENAME
+
+    def rebind_audit(self, audit: Callable[..., None]) -> None:
+        """Attach the real audit sink once app wiring provides one."""
+        with self._lock:
+            self._audit = audit
+
+    # ── what each subclass must decide ───────────────────────────────────────
+    def _default_entry(self) -> Any:
+        """The ``default`` bucket's value when the file does not say.
+
+        Called fresh at every use because the policy service's answer is a
+        mutable dict; a shared instance would let one caller's edit leak into
+        the next caller's defaults.
+        """
+        raise NotImplementedError
+
+    def _resolve_from(
+        self,
+        data: Dict[str, Any],
+        *,
+        user_email: Optional[str],
+        workspace_id: Optional[str],
+    ) -> ResolvedT:
+        """Apply this dial's scope precedence to already-loaded ``data``.
+
+        Pure over ``data`` and lock-free, so holders of ``_lock`` can reuse it
+        without re-entering a non-reentrant lock.
+        """
+        raise NotImplementedError
+
+    # ── storage ──────────────────────────────────────────────────────────────
+    def _empty(self) -> Dict[str, Any]:
+        return {"default": self._default_entry(), "users": {}, "workspaces": {}}
+
+    def _read(self) -> Dict[str, Any]:
+        if not self._path.exists():
+            return self._empty()
+        try:
+            data = json.loads(self._path.read_text(encoding="utf-8"))
+        except Exception:
+            return self._empty()
+        if not isinstance(data, dict):
+            return self._empty()
+        data.setdefault("default", self._default_entry())
+        data.setdefault("users", {})
+        data.setdefault("workspaces", {})
+        return data
+
+    def _write(self, data: Dict[str, Any]) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        atomic_write_json(self._path, data)
+
+    # ── reading ──────────────────────────────────────────────────────────────
+    def resolve(
+        self,
+        *,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+    ) -> ResolvedT:
+        with self._lock:
+            data = self._read()
+        return self._resolve_from(
+            data, user_email=user_email, workspace_id=workspace_id,
+        )

package/latticeai/services/model_capability_registry.py

@@ -636,11 +636,6 @@ def get_all_capabilities() -> List[ModelCapability]:
     return [*_REGISTRY, *_LEGACY_REGISTRY]
 
 
-def get_recommended_capabilities() -> List[ModelCapability]:
-    """Current-generation entries: catalog, download and recommendation input."""
-    return list(_REGISTRY)
-
-
 def get_legacy_capabilities() -> List[ModelCapability]:
     """Recognised-only entries: never offered, never recommended, still named."""
     return list(_LEGACY_REGISTRY)
@@ -663,12 +658,6 @@ def is_recognized_model(model_id: str) -> bool:
     return get_capability(model_id) is not None
 
 
-def is_recommended_model(model_id: str) -> bool:
-    """True only for current-generation entries — the download/offer gate."""
-    cap = get_capability(model_id)
-    return cap is not None and cap.lifecycle == RECOMMENDED
-
-
 def build_engine_model_catalog() -> Dict[str, List[Dict[str, Any]]]:
     """Return legacy ENGINE_MODEL_CATALOG shape, enriched with rich fields.
 
@@ -717,7 +706,3 @@ def get_verified_models() -> List[Dict[str, Any]]:
         if c.verification.hf_exists and c.verification.has_config and c.verification.has_tokenizer
     ]
 
-
-# Back-compat: expose a simple list mirroring the old top-level for mlx.
-# Recommended entries only — same reasoning as build_engine_model_catalog.
-LOCAL_MLX_MODELS = [c.to_legacy_dict() for c in _REGISTRY if "local_mlx" in c.provider_hints]

package/latticeai/services/model_catalog.py

@@ -15,10 +15,6 @@ import re
 import sys
 from typing import Any, Dict, List, Optional
 
-from latticeai.services.model_capability_registry import (
-    LOCAL_MLX_MODELS as _LOCAL_MLX_MODELS,
-)
-
 # 5.2.0: Delegate catalog data to the structured capability registry (rich + verified).
 # This keeps backward compat for every `from ...model_catalog import ENGINE_MODEL_CATALOG`.
 from latticeai.services.model_capability_registry import (
@@ -178,9 +174,6 @@ get_all_capabilities = _get_all_capabilities
 get_capability = _get_capability
 get_verified_models = _get_verified_models
 
-# Convenience re-export for tests / places that did `from ...model_catalog import LOCAL_MLX_MODELS`
-LOCAL_MLX_MODELS = _LOCAL_MLX_MODELS  # type: ignore[name-defined]
-
 _VERSIONED_MODEL_PATTERNS = (
     ("gemma", re.compile(r"\bgemma[-\s]?(\d+(?:\.\d+)?)", re.IGNORECASE)),
     ("qwen", re.compile(r"\bqwen[-\s]?(\d+(?:\.\d+)?)", re.IGNORECASE)),

package/latticeai/services/model_loading.py

@@ -6,7 +6,6 @@ Re-exports will be added in model_runtime for compat.
 from __future__ import annotations
 
 import asyncio
-import json
 import logging
 import queue
 import subprocess
@@ -15,6 +14,8 @@ from functools import partial
 from pathlib import Path
 from typing import Any, AsyncIterator, Dict, Optional
 
+from latticeai.core.sse import sse_frame
+
 from .model_errors import ModelRuntimeError
 
 
@@ -243,7 +244,7 @@ async def prepare_and_load_model(
 
 
 def sse_event(event: str, data: Dict[str, object]) -> str:
-    return f"event: {event}\ndata: {json.dumps(data, ensure_ascii=False)}\n\n"
+    return sse_frame(event, data)
 
 
 async def prepare_and_load_model_stream(

package/latticeai/services/model_runtime/__init__.py

@@ -104,81 +104,24 @@ from latticeai.services.model_runtime.engines import (
 from latticeai.services.model_runtime.engines import (
     _LOCAL_SERVER_PROCESSES as _LOCAL_SERVER_PROCESSES,
 )
-from latticeai.services.model_runtime.engines import (
-    LMSTUDIO_BUNDLED_CLI as LMSTUDIO_BUNDLED_CLI,
-)
 from latticeai.services.model_runtime.engines import (
     LOCAL_SERVER_PROCESSES as LOCAL_SERVER_PROCESSES,
 )
-from latticeai.services.model_runtime.engines import (
-    VLLM_METAL_BIN as VLLM_METAL_BIN,
-)
-from latticeai.services.model_runtime.engines import (
-    VLLM_METAL_ENV as VLLM_METAL_ENV,
-)
-from latticeai.services.model_runtime.engines import (
-    VLLM_METAL_PYTHON as VLLM_METAL_PYTHON,
-)
 from latticeai.services.model_runtime.engines import (
     _engine_install_plan as _engine_install_plan,
 )
-from latticeai.services.model_runtime.engines import (
-    _engine_support_status as _engine_support_status,
-)
-from latticeai.services.model_runtime.engines import (
-    _ensure_llamacpp_server as _ensure_llamacpp_server,
-)
-from latticeai.services.model_runtime.engines import (
-    _ensure_lmstudio_server as _ensure_lmstudio_server,
-)
-from latticeai.services.model_runtime.engines import (
-    _ensure_ollama_server as _ensure_ollama_server,
-)
-from latticeai.services.model_runtime.engines import (
-    _ensure_vllm_server as _ensure_vllm_server,
-)
-from latticeai.services.model_runtime.engines import (
-    _find_lmstudio_cli as _find_lmstudio_cli,
-)
 from latticeai.services.model_runtime.engines import (
     _find_lmstudio_model_key as _find_lmstudio_model_key,
 )
-from latticeai.services.model_runtime.engines import (
-    _get_ollama_pulled_models as _get_ollama_pulled_models,
-)
-from latticeai.services.model_runtime.engines import (
-    _get_openai_compatible_server_models as _get_openai_compatible_server_models,
-)
 from latticeai.services.model_runtime.engines import (
     _json_request as _json_request,
 )
 from latticeai.services.model_runtime.engines import (
     _lmstudio_candidate_keys as _lmstudio_candidate_keys,
 )
-from latticeai.services.model_runtime.engines import (
-    _local_binary as _local_binary,
-)
-from latticeai.services.model_runtime.engines import (
-    _pull_ollama_model_with_progress as _pull_ollama_model_with_progress,
-)
 from latticeai.services.model_runtime.engines import (
     _safe_engine_install_plan as _safe_engine_install_plan,
 )
-from latticeai.services.model_runtime.engines import (
-    _update_env_file as _update_env_file,
-)
-from latticeai.services.model_runtime.engines import (
-    _vllm_executable as _vllm_executable,
-)
-from latticeai.services.model_runtime.engines import (
-    _vllm_metal_python as _vllm_metal_python,
-)
-from latticeai.services.model_runtime.engines import (
-    _wait_for_openai_compatible_server as _wait_for_openai_compatible_server,
-)
-from latticeai.services.model_runtime.engines import (
-    _windows_binary_candidates as _windows_binary_candidates,
-)
 from latticeai.services.model_runtime.engines import (
     engine_installed as engine_installed,
 )

package/latticeai/services/model_runtime/engines.py

@@ -1,10 +1,17 @@
 """Local engine discovery, server hand-off, and the LM Studio HTTP client.
 
-Thin wrappers over ``latticeai.services.model_engines`` that keep the historical
+Re-exports from ``latticeai.services.model_engines`` that keep the historical
 ``model_runtime`` import path alive, plus the one piece of real logic that never
 belonged in the engine layer: the LM Studio native API (list / download / load)
 and its short-lived model cache.
 
+Until 11.5.2 the re-exports were fifteen hand-written one-line functions that
+forwarded their arguments, next to second copies of ``_json_request`` and the
+LM Studio base-URL pair. A forwarding wrapper is a place two implementations
+can drift — one of the copies had already grown a different fallback — so the
+names are now bound directly to the engine layer's and there is nothing left to
+disagree with.
+
 ``_LMSTUDIO_MODELS_CACHE`` and ``_LMSTUDIO_MODELS_CACHE_TS`` are rebindable
 module state and therefore live here and nowhere else — the package
 ``__init__`` deliberately does not re-export them, because a
@@ -15,7 +22,6 @@ the live value.
 from __future__ import annotations
 
 import importlib.util
-import json
 import os
 import shutil
 import time
@@ -24,131 +30,55 @@ import urllib.request
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-from latticeai.models.router import OPENAI_COMPATIBLE_PROVIDERS, AsyncOpenAI
+from latticeai.models.router import AsyncOpenAI
 from latticeai.services.model_engines import (
     LOCAL_SERVER_PROCESSES as _LOCAL_SERVER_PROCESSES,
 )
 from latticeai.services.model_engines import (
-    engine_install_plan as _engine_install_plan,
-)
-from latticeai.services.model_engines import (
-    engine_support_status as _engine_support_status,
-)
-from latticeai.services.model_engines import (
-    ensure_llamacpp_server as _ensure_llamacpp_server,
+    _json_request as _json_request,
 )
 from latticeai.services.model_engines import (
-    ensure_lmstudio_server as _ensure_lmstudio_server,
-)
-from latticeai.services.model_engines import (
-    ensure_ollama_server as _ensure_ollama_server,
+    engine_install_plan as _engine_install_plan,
 )
 from latticeai.services.model_engines import (
-    ensure_vllm_server as _ensure_vllm_server,
+    engine_support_status as engine_support_status,
 )
 from latticeai.services.model_engines import (
-    find_lmstudio_cli as _find_lmstudio_cli,
+    ensure_llamacpp_server as ensure_llamacpp_server,
 )
 from latticeai.services.model_engines import (
-    get_ollama_pulled_models as _get_ollama_pulled_models,
+    ensure_lmstudio_server as ensure_lmstudio_server,
 )
 from latticeai.services.model_engines import (
-    get_openai_compatible_server_models as _get_openai_compatible_server_models,
+    ensure_ollama_server as ensure_ollama_server,
 )
+from latticeai.services.model_engines import ensure_vllm_server as ensure_vllm_server
+from latticeai.services.model_engines import find_lmstudio_cli as find_lmstudio_cli
 from latticeai.services.model_engines import (
-    local_binary as _local_binary,
+    get_ollama_pulled_models as get_ollama_pulled_models,
 )
 from latticeai.services.model_engines import (
-    pull_ollama_model_with_progress as _pull_ollama_model_with_progress,
+    get_openai_compatible_server_models as get_openai_compatible_server_models,
 )
+from latticeai.services.model_engines import lmstudio_api_base as lmstudio_api_base
 from latticeai.services.model_engines import (
-    vllm_executable as _vllm_executable,
+    lmstudio_native_api_base as lmstudio_native_api_base,
 )
+from latticeai.services.model_engines import local_binary as local_binary
 from latticeai.services.model_engines import (
-    vllm_metal_python as _vllm_metal_python,
+    pull_ollama_model_with_progress as pull_ollama_model_with_progress,
 )
+from latticeai.services.model_engines import vllm_executable as vllm_executable
+from latticeai.services.model_engines import vllm_metal_python as vllm_metal_python
 from latticeai.services.model_engines import (
-    wait_for_openai_compatible_server as _wait_for_openai_compatible_server,
+    wait_for_openai_compatible_server as wait_for_openai_compatible_server,
 )
 from latticeai.services.model_engines import (
-    windows_binary_candidates as _windows_binary_candidates,
+    windows_binary_candidates as windows_binary_candidates,
 )
 from latticeai.services.model_errors import ModelRuntimeError
 
-
-def _update_env_file(env_file: Path, key: str, value: str) -> None:
-    lines = []
-    found = False
-    if env_file.exists():
-        for line in env_file.read_text(encoding="utf-8").splitlines():
-            if line.startswith(f"{key}="):
-                lines.append(f"{key}={value}")
-                found = True
-            else:
-                lines.append(line)
-    if not found:
-        lines.append(f"{key}={value}")
-    env_file.write_text("\n".join(lines) + "\n", encoding="utf-8")
-
-
 LOCAL_SERVER_PROCESSES = _LOCAL_SERVER_PROCESSES
-VLLM_METAL_ENV = Path.home() / ".venv-vllm-metal"
-VLLM_METAL_BIN = VLLM_METAL_ENV / "bin" / "vllm"
-VLLM_METAL_PYTHON = VLLM_METAL_ENV / "bin" / "python"
-LMSTUDIO_BUNDLED_CLI = Path("/Applications/LM Studio.app/Contents/Resources/app/.webpack/lms")
-
-def windows_binary_candidates(binary: str) -> List[Path]:
-    return _windows_binary_candidates(binary)
-
-
-def local_binary(binary: str) -> Optional[str]:
-    return _local_binary(binary)
-
-
-def find_lmstudio_cli() -> Optional[str]:
-    return _find_lmstudio_cli()
-
-
-def vllm_executable() -> Optional[str]:
-    return _vllm_executable()
-
-
-def vllm_metal_python() -> Optional[str]:
-    return _vllm_metal_python()
-
-
-def _json_request(
-    url: str,
-    *,
-    method: str = "GET",
-    payload: Optional[Dict[str, Any]] = None,
-    headers: Optional[Dict[str, str]] = None,
-    timeout: float = 10.0,
-) -> Dict[str, Any]:
-    data = None
-    req_headers = dict(headers or {})
-    if payload is not None:
-        data = json.dumps(payload).encode("utf-8")
-        req_headers.setdefault("Content-Type", "application/json")
-    req = urllib.request.Request(url, data=data, headers=req_headers, method=method)
-    with urllib.request.urlopen(req, timeout=timeout) as res:
-        raw = res.read().decode("utf-8", errors="replace")
-    if not raw.strip():
-        return {}
-    return json.loads(raw)
-
-
-def lmstudio_api_base() -> str:
-    return (os.getenv("LMSTUDIO_BASE_URL") or OPENAI_COMPATIBLE_PROVIDERS["lmstudio"]["base_url"]).rstrip("/")
-
-
-def lmstudio_native_api_base() -> str:
-    base = lmstudio_api_base()
-    return base[:-3] if base.endswith("/v1") else base
-
-
-def ensure_lmstudio_server() -> None:
-    return _ensure_lmstudio_server()
 
 
 _LMSTUDIO_MODELS_CACHE: List[Dict[str, Any]] = []
@@ -280,37 +210,6 @@ def ensure_lmstudio_model(model_name: str) -> Dict[str, Any]:
         "cached": False,
     }
 
-def engine_support_status(engine: str) -> Dict[str, Any]:
-    return _engine_support_status(engine)
-
-def pull_ollama_model_with_progress(model_name: str, progress_emit=None) -> Dict[str, Any]:
-    return _pull_ollama_model_with_progress(model_name, progress_emit)
-
-
-def get_ollama_pulled_models() -> set:
-    return _get_ollama_pulled_models()
-
-
-def get_openai_compatible_server_models(provider: str) -> List[str]:
-    return _get_openai_compatible_server_models(provider)
-
-
-def ensure_ollama_server() -> None:
-    return _ensure_ollama_server()
-
-
-def wait_for_openai_compatible_server(provider: str, model_name: Optional[str] = None, timeout: int = 45) -> bool:
-    return _wait_for_openai_compatible_server(provider, model_name=model_name, timeout=timeout)
-
-
-def ensure_vllm_server(model_name: str) -> None:
-    return _ensure_vllm_server(model_name)
-
-
-def ensure_llamacpp_server(model_name: str) -> None:
-    return _ensure_llamacpp_server(model_name)
-
-
 def _safe_engine_install_plan(
     engine: str,
     *,

package/latticeai/services/model_runtime/loading.py

@@ -9,10 +9,10 @@ load itself (blocking and streaming forms) and to
 
 from __future__ import annotations
 
-import json
 from typing import Any, AsyncIterator, Dict, Optional
 
 from latticeai.core.model_resolution import ModelResolution as _ModelResolution
+from latticeai.core.sse import sse_frame
 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
@@ -151,7 +151,7 @@ async def prepare_and_load_model(
 
 
 def sse_event(event: str, data: Dict[str, Any]) -> str:
-    return f"event: {event}\ndata: {json.dumps(data, ensure_ascii=False)}\n\n"
+    return sse_frame(event, data)
 
 
 async def prepare_and_load_model_stream(