ltcai 11.5.1 → 11.5.2

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(

package/latticeai/services/network_boundary_service.py

@@ -12,12 +12,9 @@ ack is audited. Hard node filters remain in ``latticeai.core.network_boundary``.
 
 from __future__ import annotations
 
-import json
-import threading
 from pathlib import Path
 from typing import Any, Callable, Dict, Optional
 
-from latticeai.core.io_utils import atomic_write_json
 from latticeai.core.network_boundary import (
     DEFAULT_NETWORK_MODE,
     NetworkBoundaryMode,
@@ -25,11 +22,14 @@ from latticeai.core.network_boundary import (
     network_mode_contract,
     normalize_network_mode,
 )
+from latticeai.services.mode_store import JsonBackedModeService
 
 
-class NetworkBoundaryService:
+class NetworkBoundaryService(JsonBackedModeService[NetworkBoundaryMode]):
     """Load / save the network boundary dial."""
 
+    FILENAME = "network_boundary.json"
+
     def __init__(
         self,
         *,
@@ -37,36 +37,11 @@ class NetworkBoundaryService:
         default_mode: NetworkBoundaryMode | str = DEFAULT_NETWORK_MODE,
         audit: Optional[Callable[..., None]] = None,
     ) -> None:
-        self._path = Path(data_dir) / "network_boundary.json"
+        super().__init__(data_dir=data_dir, audit=audit)
         self._default = normalize_network_mode(default_mode)
-        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) / "network_boundary.json"
 
-    def rebind_audit(self, audit: Callable[..., None]) -> None:
-        with self._lock:
-            self._audit = audit
-
-    def _read(self) -> Dict[str, Any]:
-        if not self._path.exists():
-            return {"default": self._default.value, "users": {}, "workspaces": {}}
-        try:
-            data = json.loads(self._path.read_text(encoding="utf-8"))
-        except Exception:
-            return {"default": self._default.value, "users": {}, "workspaces": {}}
-        if not isinstance(data, dict):
-            return {"default": self._default.value, "users": {}, "workspaces": {}}
-        data.setdefault("default", self._default.value)
-        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 _default_entry(self) -> Any:
+        return self._default.value
 
     def _resolve_from(
         self,
@@ -85,18 +60,6 @@ class NetworkBoundaryService:
                 return normalize_network_mode(user)
         return normalize_network_mode(data.get("default") or self._default)
 
-    def resolve(
-        self,
-        *,
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-    ) -> NetworkBoundaryMode:
-        with self._lock:
-            data = self._read()
-        return self._resolve_from(
-            data, user_email=user_email, workspace_id=workspace_id,
-        )
-
     def get(
         self,
         *,

package/latticeai/services/permission_mode_service.py

@@ -14,12 +14,9 @@ not by this store.
 
 from __future__ import annotations
 
-import json
-import threading
 from pathlib import Path
 from typing import Any, Callable, Dict, Optional
 
-from latticeai.core.io_utils import atomic_write_json
 from latticeai.core.permission_mode import (
     DEFAULT_MODE,
     PermissionMode,
@@ -27,11 +24,14 @@ from latticeai.core.permission_mode import (
     mode_contract,
     normalize_mode,
 )
+from latticeai.services.mode_store import JsonBackedModeService
 
 
-class PermissionModeService:
+class PermissionModeService(JsonBackedModeService[PermissionMode]):
     """Load / save the autonomy dial."""
 
+    FILENAME = "permission_mode.json"
+
     def __init__(
         self,
         *,
@@ -39,43 +39,11 @@ class PermissionModeService:
         default_mode: PermissionMode | str = DEFAULT_MODE,
         audit: Optional[Callable[..., None]] = None,
     ) -> None:
-        self._path = Path(data_dir) / "permission_mode.json"
+        super().__init__(data_dir=data_dir, audit=audit)
         self._default = normalize_mode(default_mode)
-        self._audit = audit or (lambda *a, **kw: None)
-        self._lock = threading.Lock()
-
-    def rebind_data_dir(self, data_dir: Path) -> None:
-        """Point the store at the app's real data dir.
-
-        The wiring may instantiate this 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) / "permission_mode.json"
 
-    def rebind_audit(self, audit: Callable[..., None]) -> None:
-        """Attach the real audit sink once app wiring provides one."""
-        with self._lock:
-            self._audit = audit
-
-    def _read(self) -> Dict[str, Any]:
-        if not self._path.exists():
-            return {"default": self._default.value, "users": {}, "workspaces": {}}
-        try:
-            data = json.loads(self._path.read_text(encoding="utf-8"))
-        except Exception:
-            return {"default": self._default.value, "users": {}, "workspaces": {}}
-        if not isinstance(data, dict):
-            return {"default": self._default.value, "users": {}, "workspaces": {}}
-        data.setdefault("default", self._default.value)
-        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 _default_entry(self) -> Any:
+        return self._default.value
 
     def _resolve_from(
         self,
@@ -84,11 +52,7 @@ class PermissionModeService:
         user_email: Optional[str],
         workspace_id: Optional[str],
     ) -> PermissionMode:
-        """Scope precedence: workspace → user → process default.
-
-        Pure over ``data`` and lock-free, so holders of ``_lock`` can reuse it
-        without re-entering a non-reentrant lock.
-        """
+        """Scope precedence: workspace → user → process default."""
         if workspace_id:
             ws = (data.get("workspaces") or {}).get(str(workspace_id))
             if ws:
@@ -99,18 +63,6 @@ class PermissionModeService:
                 return normalize_mode(user)
         return normalize_mode(data.get("default") or self._default)
 
-    def resolve(
-        self,
-        *,
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-    ) -> PermissionMode:
-        with self._lock:
-            data = self._read()
-        return self._resolve_from(
-            data, user_email=user_email, workspace_id=workspace_id,
-        )
-
     def get(
         self,
         *,

package/latticeai/services/product_readiness.py

@@ -18,7 +18,7 @@ from typing import Any, Dict, List
 
 from latticeai.services.architecture_readiness import architecture_readiness
 
-PRODUCT_VERSION_TARGET = "11.5.1"
+PRODUCT_VERSION_TARGET = "11.5.2"
 
 
 @dataclass(frozen=True)

package/latticeai/services/setup_detection.py

@@ -50,6 +50,64 @@ def parse_windows_video_controllers(raw: str) -> List[Dict[str, Any]]:
     return controllers
 
 
+
+def parse_windows_cpu_info(
+    raw: str,
+    *,
+    model: str,
+    physical_cores: int,
+    logical_cores: int,
+) -> Tuple[str, int, int]:
+    """Read ``wmic cpu get Name,NumberOfCores,NumberOfLogicalProcessors``.
+
+    Whatever the output does not say keeps the value the caller already had —
+    ``wmic`` is absent on modern Windows images and prints nothing there, and
+    "0 cores" would be a worse answer than ``os.cpu_count()``'s guess.
+    """
+    for line in raw.splitlines():
+        key, _, value = line.partition("=")
+        if key == "Name" and value.strip():
+            model = value.strip()
+        elif key == "NumberOfCores" and value.strip():
+            try:
+                physical_cores = int(value.strip())
+            except ValueError:
+                quiet()
+        elif key == "NumberOfLogicalProcessors" and value.strip():
+            try:
+                logical_cores = int(value.strip())
+            except ValueError:
+                quiet()
+    return model, physical_cores, logical_cores
+
+
+#: ``IsProcessorFeaturePresent`` codes worth reporting, by instruction name.
+WINDOWS_PROCESSOR_FEATURES: Dict[int, str] = {
+    6: "sse", 10: "sse2", 13: "sse3", 19: "neon", 28: "rdrand",
+}
+
+
+def windows_processor_features() -> List[str]:
+    """Instruction-set flags from the Win32 API, or none anywhere else.
+
+    ``ctypes.windll`` exists only on Windows, so on every other platform this
+    raises and answers "nothing known" — which is the honest reading, since the
+    flags are unobtainable rather than absent.
+    """
+    try:
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32  # type: ignore[attr-defined]  # Windows-only
+        return [
+            name
+            for code, name in WINDOWS_PROCESSOR_FEATURES.items()
+            if kernel32.IsProcessorFeaturePresent(code)
+        ]
+    except Exception:
+        quiet()
+        return []
+
+
 def detect_cuda(which: WhichFn, run: RunFn) -> Tuple[bool, str, Optional[str], Optional[str]]:
     nvidia_smi = which("nvidia-smi")
     nvcc = which("nvcc")
@@ -78,4 +136,12 @@ def detect_tools(which: WhichFn, binaries: Iterable[str]) -> Dict[str, Optional[
     return {binary: which(binary) for binary in binaries}
 
 
-__all__ = ["detect_cuda", "detect_tools", "detect_wsl_from_text", "parse_windows_video_controllers"]
+__all__ = [
+    "WINDOWS_PROCESSOR_FEATURES",
+    "detect_cuda",
+    "detect_tools",
+    "detect_wsl_from_text",
+    "parse_windows_cpu_info",
+    "parse_windows_video_controllers",
+    "windows_processor_features",
+]

package/latticeai/services/tool_dispatch.py

@@ -362,10 +362,6 @@ def configure_tool_dispatch(
     )
 
 
-def agent_policy(action_name: str, args: dict) -> ToolPolicy:
-    return DEFAULT_TOOL_DISPATCH_SERVICE.policy_for(action_name, args)
-
-
 def agent_risk(action_name: str, args: dict) -> str:
     return DEFAULT_TOOL_DISPATCH_SERVICE.risk_level(action_name, args)
 

package/latticeai/services/upload_service.py

@@ -6,23 +6,15 @@ import logging
 import tempfile
 from datetime import datetime
 from pathlib import Path
-from typing import Optional
 
 from fastapi import HTTPException, Request, UploadFile
 
 from lattice_brain.ingestion import IngestionItem
+from latticeai.api.workspace_scope import resolve_workspace_scope
 from latticeai.core.quiet import quiet
 from latticeai.tools import ToolError, read_document
 
 
-def _workspace_scope_from_request(request: Request) -> Optional[str]:
-    header = request.headers.get("X-Workspace-Id")
-    if header and header.strip():
-        return header.strip()
-    query = request.query_params.get("workspace_id")
-    return query.strip() if query and query.strip() else None
-
-
 async def process_uploaded_document(
     *,
     request: Request,
@@ -39,17 +31,12 @@ async def process_uploaded_document(
     workspace_service=None,
 ) -> dict:
     enforce_rate_limit(current_user, "upload")
-    requested_workspace = _workspace_scope_from_request(request)
-    if workspace_service is not None:
-        try:
-            workspace_id = workspace_service.resolve_write_scope(
-                requested_workspace,
-                current_user or None,
-            )
-        except PermissionError as exc:
-            raise HTTPException(status_code=403, detail=str(exc)) from exc
-    else:
-        workspace_id = requested_workspace
+    workspace_id = resolve_workspace_scope(
+        request,
+        user=current_user,
+        workspace_service=workspace_service,
+        write=True,
+    )
     suffix = Path(file.filename or "upload").suffix.lower()
     allowed = {".pdf", ".docx", ".xlsx", ".pptx", ".txt", ".md", ".csv"}
     if suffix not in allowed:

package/latticeai/services/workspace_service.py

@@ -73,12 +73,6 @@ class WorkspaceService:
         self._ensure_permission(workspace_id, user_id, "write")
         return workspace_id
 
-    def can_read(self, workspace_id: str, user_id: Optional[str]) -> bool:
-        return self.store.has_permission(workspace_id, self._identity(user_id), "read")
-
-    def can_write(self, workspace_id: str, user_id: Optional[str]) -> bool:
-        return self.store.has_permission(workspace_id, self._identity(user_id), "write")
-
     def readable_workspaces(self, user_id: Optional[str]) -> list[str]:
         """Return workspace ids the caller can read.