ltcai 11.5.2 → 11.7.0

package/latticeai/services/memory_service/stores.py

@@ -1,110 +0,0 @@
-"""Reads over the real backing stores — the only place the tiers touch them.
-
-Six tiers, six backends, one rule: never invent. A workspace/snapshot/
-conversation read that fails raises :class:`MemoryServiceError` so the caller
-learns the tier is unreadable instead of receiving an empty list; a graph or
-vector read that fails degrades to ``None`` because those tiers are optional
-and report themselves as ``unavailable`` upstream.
-
-The conversation tier has two backings: the durable SQLite conversation store
-when one is wired (v4), and the legacy JSON history file otherwise.
-"""
-
-from __future__ import annotations
-
-import json
-from typing import Any, Dict, List, Optional
-
-from ._contract import MemoryCore as _Core
-from .constants import LOGGER, MemoryServiceError
-
-
-class MemoryStoreReadsMixin(_Core):
-    """The store reads. Mixed into ``MemoryService``."""
-
-    # ── helpers over the underlying stores ────────────────────────────────
-    def _workspace_memories(self, *, user_email: Optional[str], workspace_id: Optional[str]) -> List[Dict[str, Any]]:
-        try:
-            return list(self._store.list_memories(user_email=user_email, workspace_id=workspace_id).get("memories", []))
-        except Exception as exc:
-            LOGGER.exception("workspace memory read failed")
-            raise MemoryServiceError("workspace memory backend unavailable") from exc
-
-    def _all_memories(self) -> List[Dict[str, Any]]:
-        try:
-            return list(self._store.list_memories().get("memories", []))
-        except Exception as exc:
-            LOGGER.exception("global memory read failed")
-            raise MemoryServiceError("memory backend unavailable") from exc
-
-    def _snapshots(self, *, workspace_id: Optional[str]) -> List[Dict[str, Any]]:
-        try:
-            return list(self._store.list_memory_snapshots(workspace_id=workspace_id, limit=200).get("snapshots", []))
-        except Exception as exc:
-            LOGGER.exception("memory snapshot read failed")
-            raise MemoryServiceError("memory snapshot backend unavailable") from exc
-
-    def _conversations(self) -> List[Dict[str, Any]]:
-        if self._conversation_store is not None:
-            try:
-                grouped: Dict[str, List[Dict[str, Any]]] = {}
-                for item in self._conversation_store.history():
-                    grouped.setdefault(item.get("conversation_id") or "legacy-previous-history", []).append(item)
-                return [{"id": conv_id, "messages": msgs} for conv_id, msgs in grouped.items()]
-            except Exception as exc:
-                LOGGER.exception("conversation store read failed")
-                raise MemoryServiceError("conversation backend unavailable") from exc
-        if not self._history_file.exists():
-            return []
-        try:
-            with open(self._history_file, "r", encoding="utf-8") as fh:
-                data = json.load(fh)
-        except (OSError, json.JSONDecodeError, TypeError, ValueError) as exc:
-            LOGGER.exception("legacy conversation history read failed")
-            raise MemoryServiceError("conversation history is unreadable") from exc
-        if isinstance(data, dict):
-            convs = data.get("conversations")
-            if isinstance(convs, list):
-                return convs
-            return [{"id": k, **(v if isinstance(v, dict) else {"messages": v})} for k, v in data.items()]
-        if isinstance(data, list):
-            return data
-        return []
-
-    def _scoped_conversations(self, *, user_email: Optional[str], workspace_id: Optional[str]) -> List[Dict[str, Any]]:
-        if not user_email:
-            return self._conversations()
-        target_workspace = workspace_id or "personal"
-        scoped: List[Dict[str, Any]] = []
-        for conversation in self._conversations():
-            messages = conversation.get("messages") or []
-            if not isinstance(messages, list):
-                continue
-            kept = [
-                message
-                for message in messages
-                if isinstance(message, dict)
-                and message.get("user_email") == user_email
-                and (message.get("workspace_id") or "personal") == target_workspace
-            ]
-            if kept:
-                scoped.append({**conversation, "messages": kept})
-        return scoped
-
-    def _kg_stats(self) -> Optional[Dict[str, Any]]:
-        if not self._enable_graph:
-            return None
-        try:
-            return self._kg.stats()
-        except Exception:
-            LOGGER.exception("knowledge graph stats read failed")
-            return None
-
-    def _kg_index(self) -> Optional[Dict[str, Any]]:
-        if not self._enable_graph:
-            return None
-        try:
-            return self._kg.index_status()
-        except Exception:
-            LOGGER.exception("knowledge graph index status read failed")
-            return None

package/latticeai/services/mode_store.py

@@ -1,132 +0,0 @@
-"""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_recommendation.py

@@ -1,224 +0,0 @@
-"""Hardware-aware local model recommendation.
-
-Given a detected system profile (from :func:`auto_setup.probe`) this module
-classifies every model in :data:`model_catalog.ENGINE_MODEL_CATALOG` into one of
-three states — **recommended**, **compatible**, or **not_recommended** — and
-groups the result by current model family (Gemma 4, Qwen3.6, Qwen3.5, GPT-OSS,
-LFM2.5).
-
-It is intentionally pure and dependency-light: the only input is a plain dict
-describing the machine, so it is fully unit-testable without touching real
-hardware, and it does not import the FastAPI app or the runtime.  The setup /
-onboarding routers build the profile via ``auto_setup.probe().to_json()`` and
-hand it here.
-"""
-
-from __future__ import annotations
-
-import re
-from typing import Any, Dict, List, Optional
-
-from latticeai.core.model_compat import model_runtime_compatibility
-from latticeai.services.model_catalog import ENGINE_MODEL_CATALOG
-
-# ── status vocabulary ─────────────────────────────────────────────────────────
-RECOMMENDED = "recommended"
-COMPATIBLE = "compatible"
-NOT_RECOMMENDED = "not_recommended"
-
-# Engines whose models load on any OS (given the engine binary) vs. MLX which is
-# Apple-Silicon only.  Used to decide platform availability before sizing.
-_APPLE_ONLY_ENGINES = {"local_mlx"}
-
-# Family display order for the grouped view (current generations, largest
-# lineup first). Superseded families are not listed because the capability
-# registry never lets them reach the catalog — they are recognised for loading
-# only. A family missing from this list still renders, it just sorts last.
-_FAMILY_ORDER = [
-    "Gemma 4",
-    "Qwen3.6",
-    "Qwen3.5",
-    "GPT-OSS",
-    "LFM2.5",
-]
-
-# Modalities the recommender will surface. Text-only models earn their place —
-# LFM2.5 is the only thing that runs comfortably on 8GB, and GPT-OSS 20B is the
-# most-downloaded entry in the catalog — so filtering to `multimodal` would have
-# hidden two of the tiers. Each row still reports its own `modality`, so a UI
-# that wants to badge "reads pictures" can, honestly.
-_RECOMMENDABLE_MODALITIES = {"multimodal", "text"}
-
-_SIZE_RE = re.compile(r"([\d.]+)\s*(TB|GB|MB)", re.IGNORECASE)
-_UNIT_GB = {"TB": 1024.0, "GB": 1.0, "MB": 1.0 / 1024.0}
-
-
-def parse_size_gb(size: Any) -> Optional[float]:
-    """Parse a catalog ``size`` string (``"4.7GB"``, ``"963MB"``, ``"40GB+"``).
-
-    Returns ``None`` when the size is non-numeric (e.g. ``"pull required"`` or
-    ``"실행 도구에서 관리"``) so callers can treat it as "size unknown".
-    """
-    if not isinstance(size, str):
-        return None
-    match = _SIZE_RE.search(size)
-    if not match:
-        return None
-    value = float(match.group(1))
-    return round(value * _UNIT_GB[match.group(2).upper()], 3)
-
-
-def estimated_ram_gb(size_gb: float) -> float:
-    """Rough RAM needed to run a model: weights + KV cache + OS working set."""
-    return round(size_gb * 1.25 + 2.5, 2)
-
-
-def is_apple_silicon(profile: Dict[str, Any]) -> bool:
-    os_name = str(profile.get("os") or "").lower()
-    arch = str(profile.get("arch") or "").lower()
-    gpu = profile.get("gpu") or {}
-    vendor = str(gpu.get("vendor") or "").lower()
-    return os_name == "darwin" and (vendor == "apple" or arch in {"arm64", "aarch64"})
-
-
-def _ram_gb(profile: Dict[str, Any]) -> float:
-    try:
-        return max(0.0, float(profile.get("ram_mb") or 0) / 1024.0)
-    except (TypeError, ValueError):
-        return 0.0
-
-
-def _engine_available(engine: str, profile: Dict[str, Any]) -> bool:
-    if engine in _APPLE_ONLY_ENGINES:
-        return is_apple_silicon(profile)
-    # ollama / llamacpp / lmstudio / vllm run cross-platform once installed.
-    return True
-
-
-def _classify_one(
-    model: Dict[str, Any],
-    *,
-    engine: str,
-    engine_available: bool,
-    ram_gb: float,
-) -> Dict[str, Any]:
-    size_gb = parse_size_gb(model.get("size"))
-    need_gb = estimated_ram_gb(size_gb) if size_gb is not None else None
-    runtime = model_runtime_compatibility(str(model.get("id") or ""), engine=engine)
-
-    if not engine_available:
-        status, reason = NOT_RECOMMENDED, "Apple Silicon과 MLX-VLM이 필요합니다"
-    elif runtime.get("supported") is False:
-        status = NOT_RECOMMENDED
-        reason = str(runtime.get("user_message") or "이 모델은 현재 설치된 실행 런타임에서 지원되지 않습니다")
-    elif need_gb is None:
-        # Tool-managed/pull models have no fixed on-disk size, so treat them as
-        # compatible and let the execution tool validate the exact model.
-        status, reason = COMPATIBLE, "선택한 실행 방식에서 필요할 때 모델을 받습니다"
-    elif ram_gb <= 0:
-        status, reason = COMPATIBLE, "메모리 정보를 확인하지 못했습니다. 불러오기 전에 검증합니다"
-    elif need_gb <= ram_gb * 0.75:
-        status, reason = RECOMMENDED, f"현재 메모리에서 안정적으로 사용할 가능성이 높습니다 (~{need_gb:.0f} GB / {ram_gb:.0f} GB)"
-    elif need_gb <= ram_gb * 0.9:
-        status, reason = COMPATIBLE, f"사용 가능하지만 여유가 적습니다 (~{need_gb:.0f} GB / {ram_gb:.0f} GB)"
-    else:
-        status, reason = NOT_RECOMMENDED, f"권장 메모리가 부족합니다 (~{need_gb:.0f} GB 필요, 현재 {ram_gb:.0f} GB)"
-
-    rich = {
-        "id": model.get("id"),
-        "name": model.get("name"),
-        "model_name": model.get("model_name") or model.get("name"),
-        "family": model.get("family"),
-        "tag": model.get("tag"),
-        "modality": model.get("modality") or "multimodal",
-        "size": model.get("size"),
-        "size_gb": size_gb,
-        "required_ram_gb": need_gb,
-        "status": status,
-        "reason": reason,
-        "source_country": model.get("source_country"),
-        "source_company": model.get("source_company"),
-        "execution_method": model.get("execution_method"),
-        "run_location": model.get("run_location"),
-        "internet_requirement": model.get("internet_requirement"),
-        "source_display_order": model.get("source_display_order"),
-        "runtime_compatibility": runtime,
-        # 5.2+ user-focused transparency
-        "hf_repo_id": model.get("hf_repo_id"),
-        "quantization": model.get("quantization"),
-        "download_strategy": model.get("download_strategy"),
-        "load_strategy": model.get("load_strategy"),
-        "hardware": model.get("hardware"),
-        "license": model.get("license"),
-        "safety_notes": model.get("safety_notes"),
-        "verification": model.get("verification"),
-        "recommended_default": model.get("recommended_default", False),
-    }
-    return rich
-
-
-def _family_rank(family: str) -> int:
-    try:
-        return _FAMILY_ORDER.index(family)
-    except ValueError:
-        return len(_FAMILY_ORDER)
-
-
-def recommend_catalog(profile: Dict[str, Any], *, engine: str = "local_mlx") -> Dict[str, Any]:
-    """Classify ``engine``'s catalog for the given machine ``profile``.
-
-    ``profile`` is a dict shaped like ``auto_setup.SystemProfile.to_json()``
-    (``os``, ``arch``, ``ram_mb``, ``gpu={vendor,vram_mb}`` …).
-    """
-    models = [
-        model for model in ENGINE_MODEL_CATALOG.get(engine, [])
-        if str(model.get("modality") or "").lower() in _RECOMMENDABLE_MODALITIES
-    ]
-    engine_available = _engine_available(engine, profile)
-    ram_gb = _ram_gb(profile)
-
-    classified = [
-        _classify_one(m, engine=engine, engine_available=engine_available, ram_gb=ram_gb)
-        for m in models
-    ]
-
-    counts = {RECOMMENDED: 0, COMPATIBLE: 0, NOT_RECOMMENDED: 0}
-    for item in classified:
-        counts[item["status"]] += 1
-
-    # Group by family, ordered, with the best pick per family surfaced.
-    by_family: Dict[str, Dict[str, Any]] = {}
-    for item in classified:
-        fam = item["family"] or "Other"
-        bucket = by_family.setdefault(fam, {"family": fam, "models": [], "best": None})
-        bucket["models"].append(item)
-
-    def _best(models: List[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
-        # Prefer recommended, then compatible; within a tier prefer the largest
-        # model that still fits (more capable).
-        for tier in (RECOMMENDED, COMPATIBLE):
-            tier_models = [m for m in models if m["status"] == tier]
-            if tier_models:
-                return max(tier_models, key=lambda m: m["size_gb"] or 0.0)
-        return None
-
-    families = []
-    for fam in sorted(by_family, key=_family_rank):
-        bucket = by_family[fam]
-        bucket["best"] = _best(bucket["models"])
-        families.append(bucket)
-
-    # Overall top pick: the largest recommended model on this machine.
-    recommended_models = [m for m in classified if m["status"] == RECOMMENDED]
-    top_pick = max(recommended_models, key=lambda m: m["size_gb"] or 0.0) if recommended_models else None
-
-    return {
-        "engine": engine,
-        "engine_available": engine_available,
-        "apple_silicon": is_apple_silicon(profile),
-        "ram_gb": round(ram_gb, 1),
-        "counts": counts,
-        "top_pick": top_pick,
-        "families": families,
-        "models": classified,
-    }

package/latticeai/services/model_runtime/cloud.py

@@ -1,87 +0,0 @@
-"""Cloud model verification — does this key actually answer for this model?
-
-A one-token chat completion per configured cloud model, cached per service
-instance for :data:`CLOUD_VERIFY_TTL_SECONDS`. A model the router already knows
-is unavailable is recorded as such without a network call.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import os
-import time
-from typing import Any, Dict, Optional
-
-from latticeai.models.router import (
-    OPENAI_COMPATIBLE_PROVIDERS,
-    AsyncOpenAI,
-    parse_model_ref,
-)
-from latticeai.services.model_runtime.state import ModelRuntimeState
-
-CLOUD_VERIFY_TTL_SECONDS = 600
-
-async def _probe_cloud_model(model_ref: str) -> Dict[str, Any]:
-    provider, model_name = parse_model_ref(model_ref)
-    config = OPENAI_COMPATIBLE_PROVIDERS.get(provider)
-    if not config:
-        return {"ok": False, "reason": f"Unsupported provider: {provider}"}
-
-    api_key = os.getenv(config["env_key"]) or config.get("api_key_fallback")
-    if not api_key:
-        return {"ok": False, "reason": f"Missing API key: {config['env_key']}"}
-
-    base_url = os.getenv(config.get("base_url_env", "")) if config.get("base_url_env") else None
-    base_url = base_url or config.get("base_url")
-    try:
-        # base_url is passed only when configured: an explicit None is not
-        # the same as omitting the argument.
-        client = (
-            AsyncOpenAI(api_key=api_key, base_url=base_url)
-            if base_url
-            else AsyncOpenAI(api_key=api_key)
-        )
-        await asyncio.wait_for(
-            client.chat.completions.create(
-                model=model_name,
-                messages=[{"role": "user", "content": "ping"}],
-                max_tokens=1,
-                temperature=0,
-            ),
-            timeout=15,
-        )
-        return {"ok": True, "reason": "ok"}
-    except Exception as e:
-        return {"ok": False, "reason": str(e)[:220]}
-
-
-async def verify_cloud_models(
-    force: bool = False,
-    provider_filter: Optional[str] = None,
-    *,
-    state: ModelRuntimeState,
-    cache: Dict[str, Dict[str, Any]],
-) -> Dict[str, Dict]:
-    now = time.time()
-    r = state.router
-    cloud_items = [item for item in (r.detected_cloud_models() if r else []) if item.get("tag") == "cloud"]
-    if provider_filter:
-        cloud_items = [item for item in cloud_items if item.get("provider") == provider_filter]
-
-    results: Dict[str, Dict] = {}
-    for item in cloud_items:
-        model_ref = item["id"]
-        cached = cache.get(model_ref)
-        if not force and cached and (now - cached.get("ts", 0) <= CLOUD_VERIFY_TTL_SECONDS):
-            results[model_ref] = cached
-            continue
-        if item.get("available") is False:
-            record = {"ok": False, "reason": item.get("requires") or "API key missing", "ts": now}
-            cache[model_ref] = record
-            results[model_ref] = record
-            continue
-        probe = await _probe_cloud_model(model_ref)
-        record = {"ok": bool(probe.get("ok")), "reason": probe.get("reason", ""), "ts": now}
-        cache[model_ref] = record
-        results[model_ref] = record
-    return results

package/latticeai/services/network_boundary_service.py

@@ -1,117 +0,0 @@
-"""Persisted network-boundary preference for hybrid local + cloud turns.
-
-Mirrors PermissionModeService:
-
-* process default (env ``LATTICEAI_NETWORK_MODE`` or local_only)
-* per-user override
-* per-workspace override (wins over user)
-
-Switching to ``cloud_allowed`` requires ``acknowledge_risk=True`` once; the
-ack is audited. Hard node filters remain in ``latticeai.core.network_boundary``.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any, Callable, Dict, Optional
-
-from latticeai.core.network_boundary import (
-    DEFAULT_NETWORK_MODE,
-    NetworkBoundaryMode,
-    network_mode_catalog,
-    network_mode_contract,
-    normalize_network_mode,
-)
-from latticeai.services.mode_store import JsonBackedModeService
-
-
-class NetworkBoundaryService(JsonBackedModeService[NetworkBoundaryMode]):
-    """Load / save the network boundary dial."""
-
-    FILENAME = "network_boundary.json"
-
-    def __init__(
-        self,
-        *,
-        data_dir: Path,
-        default_mode: NetworkBoundaryMode | str = DEFAULT_NETWORK_MODE,
-        audit: Optional[Callable[..., None]] = None,
-    ) -> None:
-        super().__init__(data_dir=data_dir, audit=audit)
-        self._default = normalize_network_mode(default_mode)
-
-    def _default_entry(self) -> Any:
-        return self._default.value
-
-    def _resolve_from(
-        self,
-        data: Dict[str, Any],
-        *,
-        user_email: Optional[str],
-        workspace_id: Optional[str],
-    ) -> NetworkBoundaryMode:
-        if workspace_id:
-            ws = (data.get("workspaces") or {}).get(str(workspace_id))
-            if ws:
-                return normalize_network_mode(ws)
-        if user_email:
-            user = (data.get("users") or {}).get(str(user_email).lower())
-            if user:
-                return normalize_network_mode(user)
-        return normalize_network_mode(data.get("default") or self._default)
-
-    def get(
-        self,
-        *,
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        mode = self.resolve(user_email=user_email, workspace_id=workspace_id)
-        contract = network_mode_contract(mode)
-        contract["catalog"] = network_mode_catalog()
-        contract["scope"] = {
-            "user_email": user_email,
-            "workspace_id": workspace_id,
-        }
-        return contract
-
-    def set_mode(
-        self,
-        mode: NetworkBoundaryMode | str,
-        *,
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-        acknowledge_risk: bool = False,
-        source: str = "api",
-    ) -> Dict[str, Any]:
-        mode = normalize_network_mode(mode)
-        if mode == NetworkBoundaryMode.CLOUD_ALLOWED and not acknowledge_risk:
-            raise PermissionError(
-                "cloud_allowed mode requires acknowledge_risk=true "
-                "(minimal related Knowledge Graph nodes may leave this machine)"
-            )
-        with self._lock:
-            data = self._read()
-            previous = self._resolve_from(
-                data, user_email=user_email, workspace_id=workspace_id,
-            )
-            if workspace_id:
-                data.setdefault("workspaces", {})[str(workspace_id)] = mode.value
-            elif user_email:
-                data.setdefault("users", {})[str(user_email).lower()] = mode.value
-            else:
-                data["default"] = mode.value
-            self._write(data)
-        self._audit(
-            "network_boundary_changed",
-            user_email=user_email,
-            workspace_id=workspace_id,
-            previous=previous.value,
-            mode=mode.value,
-            source=source,
-            acknowledge_risk=bool(acknowledge_risk),
-        )
-        return self.get(user_email=user_email, workspace_id=workspace_id)
-
-
-__all__ = ["NetworkBoundaryService"]