ltcai 10.0.0 → 10.3.0

package/latticeai/services/hybrid_policy.py

@@ -0,0 +1,178 @@
+"""User-configurable hybrid policy (Phase 3).
+
+Controls:
+
+* which node types / metadata flags are blocked from leaving the machine
+* whether cloud-derived KG expansion auto-commits or stages for review
+* whether multimodal (video) cloud calls are allowed when cloud mode is on
+
+Persisted under the data dir, scoped like NetworkBoundaryService
+(workspace → user → default).
+"""
+
+from __future__ import annotations
+
+import json
+import threading
+from pathlib import Path
+from typing import Any, Callable, 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,
+)
+
+DEFAULT_BLOCKED_TYPES: List[str] = []
+DEFAULT_BLOCKED_FLAGS: List[str] = sorted(HARD_BLOCK_METADATA_FLAGS)
+DEFAULT_AUTO_COMMIT = False
+DEFAULT_ALLOW_MULTIMODAL = False
+
+
+def _default_policy() -> Dict[str, Any]:
+    return {
+        "blocked_node_types": list(DEFAULT_BLOCKED_TYPES),
+        "blocked_metadata_flags": list(DEFAULT_BLOCKED_FLAGS),
+        "auto_commit": DEFAULT_AUTO_COMMIT,
+        "allow_multimodal": DEFAULT_ALLOW_MULTIMODAL,
+        "min_extraction_confidence": 0.55,
+    }
+
+
+class HybridPolicyService:
+    """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"
+
+    def rebind_audit(self, audit: Callable[..., None]) -> None:
+        with self._lock:
+            self._audit = audit
+
+    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(
+        self,
+        data: Dict[str, Any],
+        *,
+        user_email: Optional[str],
+        workspace_id: Optional[str],
+    ) -> Dict[str, Any]:
+        policy = dict(data.get("default") or _default_policy())
+        if user_email:
+            user = (data.get("users") or {}).get(str(user_email).lower())
+            if isinstance(user, dict):
+                policy.update(user)
+        if workspace_id:
+            ws = (data.get("workspaces") or {}).get(str(workspace_id))
+            if isinstance(ws, dict):
+                policy.update(ws)
+        # Always union hard-coded circuit breakers.
+        blocked_types: Set[str] = set(policy.get("blocked_node_types") or [])
+        blocked_types |= set(HARD_BLOCK_NODE_TYPES)
+        blocked_flags: Set[str] = set(policy.get("blocked_metadata_flags") or [])
+        blocked_flags |= set(HARD_BLOCK_METADATA_FLAGS)
+        policy["blocked_node_types"] = sorted(blocked_types)
+        policy["blocked_metadata_flags"] = sorted(blocked_flags)
+        policy["auto_commit"] = bool(policy.get("auto_commit", False))
+        policy["allow_multimodal"] = bool(policy.get("allow_multimodal", False))
+        try:
+            policy["min_extraction_confidence"] = float(
+                policy.get("min_extraction_confidence", 0.55)
+            )
+        except (TypeError, ValueError):
+            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],
+        *,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+        source: str = "api",
+    ) -> Dict[str, Any]:
+        allowed = {
+            "blocked_node_types",
+            "blocked_metadata_flags",
+            "auto_commit",
+            "allow_multimodal",
+            "min_extraction_confidence",
+        }
+        clean = {k: v for k, v in (patch or {}).items() if k in allowed}
+        with self._lock:
+            data = self._read()
+            previous = self._resolve_raw(
+                data, user_email=user_email, workspace_id=workspace_id
+            )
+            if workspace_id:
+                bucket = data.setdefault("workspaces", {})
+                current = dict(bucket.get(str(workspace_id)) or {})
+                current.update(clean)
+                bucket[str(workspace_id)] = current
+            elif user_email:
+                bucket = data.setdefault("users", {})
+                key = str(user_email).lower()
+                current = dict(bucket.get(key) or {})
+                current.update(clean)
+                bucket[key] = current
+            else:
+                current = dict(data.get("default") or _default_policy())
+                current.update(clean)
+                data["default"] = current
+            self._write(data)
+        resolved = self.resolve(user_email=user_email, workspace_id=workspace_id)
+        self._audit(
+            "hybrid_policy_changed",
+            user_email=user_email,
+            workspace_id=workspace_id,
+            previous=previous,
+            policy=resolved,
+            source=source,
+        )
+        return resolved
+
+
+__all__ = ["HybridPolicyService", "DEFAULT_AUTO_COMMIT", "DEFAULT_ALLOW_MULTIMODAL"]

package/latticeai/services/memory_service.py

@@ -26,8 +26,8 @@ import logging
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-from latticeai.core.workspace_os_utils import _file_size
 from latticeai.core.timeutil import now_iso as _now
+from latticeai.core.workspace_os_utils import _file_size
 
 # Personal workspace memory kinds (from WorkspaceOS.MEMORY_KINDS).
 WORKSPACE_KINDS = (

package/latticeai/services/model_catalog.py

@@ -15,14 +15,23 @@ import re
 import sys
 from typing import 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 (
     build_engine_model_catalog as _build_engine_model_catalog,
+)
+from latticeai.services.model_capability_registry import (
     get_all_capabilities as _get_all_capabilities,
+)
+from latticeai.services.model_capability_registry import (
     get_capability as _get_capability,
+)
+from latticeai.services.model_capability_registry import (
     get_verified_models as _get_verified_models,
-    LOCAL_MLX_MODELS as _LOCAL_MLX_MODELS,
 )
 
 ENGINE_INSTALLERS = {

package/latticeai/services/model_engines.py

@@ -22,8 +22,9 @@ import urllib.request
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-from latticeai.services.model_errors import ModelRuntimeError
+from latticeai.core.quiet import quiet
 from latticeai.services.model_catalog import ENGINE_INSTALLERS
+from latticeai.services.model_errors import ModelRuntimeError
 from latticeai.services.process_audit import (
     CommandConfirmationError,
     append_process_audit_event,
@@ -127,7 +128,9 @@ def _json_request(
 def lmstudio_api_base() -> str:
     # late to avoid issues
     try:
-        from latticeai.services.model_runtime import OPENAI_COMPATIBLE_PROVIDERS  # type: ignore
+        from latticeai.services.model_runtime import (
+            OPENAI_COMPATIBLE_PROVIDERS,  # type: ignore
+        )
         prov = OPENAI_COMPATIBLE_PROVIDERS
     except Exception:
         prov = {}
@@ -145,7 +148,7 @@ def ensure_lmstudio_server() -> None:
         _json_request(f"{base_url}/api/v1/models", headers={"Authorization": "Bearer lmstudio"}, timeout=2.5)
         return
     except Exception:
-        pass
+        quiet()
 
     cli = find_lmstudio_cli()
     if not cli:
@@ -180,7 +183,7 @@ def ensure_ollama_server() -> None:
         if probe.returncode == 0:
             return
     except Exception:
-        pass
+        quiet()
     subprocess.Popen(
         [ollama, "serve"],
         stdout=subprocess.DEVNULL,
@@ -194,13 +197,16 @@ def ensure_ollama_server() -> None:
             if probe.returncode == 0:
                 return
         except Exception:
-            pass
+            quiet()
         time.sleep(0.5)
     raise ModelRuntimeError(status_code=500, detail="Ollama 서버를 자동으로 시작하지 못했습니다.")
 
 
 def get_openai_compatible_server_models(provider: str) -> List[str]:
-    from latticeai.services.model_runtime import OPENAI_COMPATIBLE_PROVIDERS, get_lmstudio_models
+    from latticeai.services.model_runtime import (
+        OPENAI_COMPATIBLE_PROVIDERS,
+        get_lmstudio_models,
+    )
 
     if provider == "lmstudio":
         models = []
@@ -255,7 +261,11 @@ def wait_for_openai_compatible_server(provider: str, model_name: Optional[str] =
 
 
 def ensure_vllm_server(model_name: str) -> None:
-    from latticeai.services.model_runtime import download_hf_model, hf_model_dir, hf_model_ready
+    from latticeai.services.model_runtime import (
+        download_hf_model,
+        hf_model_dir,
+        hf_model_ready,
+    )
 
     served_models = get_openai_compatible_server_models("vllm")
     if model_name in served_models:
@@ -301,7 +311,11 @@ def ensure_vllm_server(model_name: str) -> None:
 
 
 def ensure_llamacpp_server(model_name: str) -> None:
-    from latticeai.services.model_runtime import download_hf_model, hf_model_dir, hf_model_ready
+    from latticeai.services.model_runtime import (
+        download_hf_model,
+        hf_model_dir,
+        hf_model_ready,
+    )
 
     served_models = get_openai_compatible_server_models("llamacpp")
     if model_name in served_models:
@@ -368,7 +382,7 @@ def pull_ollama_model_with_progress(model_name: str, progress_emit=None) -> Dict
     last_percent: Optional[float] = None
     lines: List[str] = []
     try:
-        assert process.stdout is not None
+        assert process.stdout is not None  # noqa: S101 — invariant guard on a code path with no caller-facing error
         for raw_line in process.stdout:
             for part in re.split(r"[\r\n]+", raw_line):
                 line = part.strip()
@@ -597,17 +611,24 @@ async def _smoke_test_loaded_model(
     """
     # late imports to avoid circular and keep lattice_brain/latticeai clean
     try:
-        from latticeai.services.model_runtime import (
-            _LOCAL_SMOKE_ENGINES,
-            _SMOKE_PROMPT,
+        import asyncio
+
+        from latticeai.core.model_compat import (
+            classify_smoke_response as _classify_smoke_response,
         )
         from latticeai.core.model_compat import (
             ensure_profile as _ensure_compat_profile,
+        )
+        from latticeai.core.model_compat import (
             fast_postprocess as _compat_fast_postprocess,
-            classify_smoke_response as _classify_smoke_response,
+        )
+        from latticeai.core.model_compat import (
             record_smoke_result as _record_smoke_result,
         )
-        import asyncio
+        from latticeai.services.model_runtime import (
+            _LOCAL_SMOKE_ENGINES,
+            _SMOKE_PROMPT,
+        )
     except Exception as e:
         return {"ok": False, "reason": f"smoke import failed: {e}", "skipped": True}
 

package/latticeai/services/model_loading.py

@@ -17,16 +17,18 @@ from typing import Any, AsyncIterator, Dict, Optional
 
 from .model_errors import ModelRuntimeError
 
+
 # Late imports to avoid circulars during extraction. The state argument is
 # mandatory so this module cannot fall back to ambient process configuration.
 def _get_model_runtime_deps(runtime_state: Any):
     from .model_runtime import (
+        MODEL_ENGINE_ALIASES,
         _download_allowed,
         _download_block,
         _engine_install_block,
         _friendly_model_runtime_error,
-        _ModelResolution,
         _model_runtime_compatibility,
+        _ModelResolution,
         _smoke_test_loaded_model,
         download_hf_model,
         engine_installed,
@@ -40,7 +42,6 @@ def _get_model_runtime_deps(runtime_state: Any):
         hf_model_dir,
         hf_model_ready,
         local_binary,
-        MODEL_ENGINE_ALIASES,
         model_download_progress_payload,
         normalize_local_model_request,
         parse_model_ref,

package/latticeai/services/model_runtime.py

@@ -20,42 +20,78 @@ from dataclasses import dataclass, field, fields
 from pathlib import Path
 from typing import Any, AsyncIterator, Callable, Dict, List, Optional
 
-from .model_errors import ModelRuntimeError
-
+from latticeai.core.model_compat import (
+    SMOKE_PROMPT as _SMOKE_PROMPT,
+)
+from latticeai.core.model_compat import (
+    friendly_model_runtime_error as _friendly_model_runtime_error,
+)
+from latticeai.core.model_compat import (
+    model_runtime_compatibility as _model_runtime_compatibility,
+)
+from latticeai.core.model_resolution import ModelResolution as _ModelResolution
 from latticeai.models.router import (
-    AsyncOpenAI,
     HF_MODELS_ROOT,
     OPENAI_COMPATIBLE_PROVIDERS,
+    AsyncOpenAI,
     ensure_mlx_runtime,
     hf_cache_model_dir,
     hf_model_dir,
     parse_model_ref,
 )
-from latticeai.core.model_resolution import ModelResolution as _ModelResolution
-from latticeai.core.model_compat import (
-    friendly_model_runtime_error as _friendly_model_runtime_error,
-    model_runtime_compatibility as _model_runtime_compatibility,
-    SMOKE_PROMPT as _SMOKE_PROMPT,
+
+from .model_engines import (
+    LOCAL_SERVER_PROCESSES as _LOCAL_SERVER_PROCESSES,
+)
+from .model_engines import (
+    engine_install_plan as _engine_install_plan,
+)
+from .model_engines import (
+    engine_support_status as _engine_support_status,
+)
+from .model_engines import (
+    ensure_llamacpp_server as _ensure_llamacpp_server,
 )
 from .model_engines import (
     ensure_lmstudio_server as _ensure_lmstudio_server,
+)
+from .model_engines import (
     ensure_ollama_server as _ensure_ollama_server,
+)
+from .model_engines import (
     ensure_vllm_server as _ensure_vllm_server,
-    ensure_llamacpp_server as _ensure_llamacpp_server,
+)
+from .model_engines import (
     find_lmstudio_cli as _find_lmstudio_cli,
-    get_openai_compatible_server_models as _get_openai_compatible_server_models,
-    pull_ollama_model_with_progress as _pull_ollama_model_with_progress,
+)
+from .model_engines import (
     get_ollama_pulled_models as _get_ollama_pulled_models,
-    engine_support_status as _engine_support_status,
-    engine_install_plan as _engine_install_plan,
+)
+from .model_engines import (
+    get_openai_compatible_server_models as _get_openai_compatible_server_models,
+)
+from .model_engines import (
     install_engine as _install_engine,
+)
+from .model_engines import (
     local_binary as _local_binary,
+)
+from .model_engines import (
+    pull_ollama_model_with_progress as _pull_ollama_model_with_progress,
+)
+from .model_engines import (
     vllm_executable as _vllm_executable,
+)
+from .model_engines import (
     vllm_metal_python as _vllm_metal_python,
+)
+from .model_engines import (
     wait_for_openai_compatible_server as _wait_for_openai_compatible_server,
+)
+from .model_engines import (
     windows_binary_candidates as _windows_binary_candidates,
-    LOCAL_SERVER_PROCESSES as _LOCAL_SERVER_PROCESSES,
 )
+from .model_errors import ModelRuntimeError
 
 # ``model_loading._get_model_runtime_deps`` imports these private names from
 # this module to preserve the historical model_runtime wiring surface.
@@ -174,16 +210,20 @@ def configure_model_runtime(**deps: Any) -> "ModelRuntimeService":
 # Catalog data + version-dedup helpers live in ``model_catalog``; re-exported
 # here so existing ``from ...model_runtime import ENGINE_MODEL_CATALOG`` imports
 # keep working.
+from latticeai.core.quiet import (  # noqa: E402 — re-export placed after the globals it documents
+    quiet,  # noqa: E402 — re-export placed after the globals it documents
+)
 from latticeai.services.model_catalog import (  # noqa: E402, F401 (re-export after the module globals it documents)
+    _VERSIONED_MODEL_PATTERNS,
     ENGINE_INSTALLERS,
     ENGINE_MODEL_CATALOG,
     MODEL_ENGINE_ALIASES,
-    _VERSIONED_MODEL_PATTERNS,
     _model_family_version,
     _version_tuple,
     filter_lower_family_versions,
 )
 
+
 def _update_env_file(env_file: Path, key: str, value: str) -> None:
     lines = []
     found = False
@@ -471,7 +511,7 @@ def hf_repo_files_with_sizes(repo_id: str) -> List[Dict[str, object]]:
         if files:
             return files
     except TypeError:
-        pass
+        quiet()
     except Exception as e:
         logging.warning("huggingface model_info failed for %s: %s", repo_id, e)
 
@@ -562,7 +602,18 @@ def download_hf_model(
                     downloaded_before = downloaded_bytes
                     last_emit = {"at": 0.0, "percent": -1.0}
 
-                    def emit_byte_progress(done_bytes: float) -> None:
+                    def emit_byte_progress(
+                        done_bytes: float,
+                        # Bound per iteration: this callback outlives the loop
+                        # body when a download runs long, and late binding
+                        # would report every file's progress against the last
+                        # file's offsets.
+                        downloaded_before: int = downloaded_before,
+                        size: Any = size,
+                        index: int = index,
+                        last_emit: dict = last_emit,
+                        filename: str = filename,
+                    ) -> None:
                         done = max(0, int(done_bytes or 0))
                         if total_bytes:
                             aggregate = min(total_bytes, downloaded_before + done)

package/latticeai/services/multimodal_streaming.py

@@ -0,0 +1,123 @@
+"""Multimodal / video streaming contracts behind NetworkBoundaryMode (Phase 3).
+
+Video generation and other multimodal cloud calls share the same boundary dial
+as text: nothing leaves the machine unless mode is CLOUD_ALLOWED *and* the
+hybrid policy has ``allow_multimodal=True``.
+
+This module is intentionally adapter-shaped: concrete providers (Runway, Luma,
+Veo-compatible endpoints, etc.) plug in later without changing the chat path.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, AsyncIterator, Dict, List, Optional, Protocol
+
+from latticeai.core.network_boundary import (
+    NetworkBoundaryMode,
+    normalize_network_mode,
+)
+from latticeai.services.hybrid_context import MinimalContext
+
+
+@dataclass
+class MultimodalTurnResult:
+    user_message: str
+    media_urls: List[str] = field(default_factory=list)
+    media_kind: str = "video"  # video | image | audio
+    answer_text: str = ""
+    sent_node_ids: List[str] = field(default_factory=list)
+    provider: str = ""
+    model: str = ""
+    usage: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "user_message": self.user_message,
+            "media_urls": list(self.media_urls),
+            "media_kind": self.media_kind,
+            "answer_text": self.answer_text,
+            "sent_node_ids": list(self.sent_node_ids),
+            "provider": self.provider,
+            "model": self.model,
+            "usage": dict(self.usage),
+        }
+
+
+class MultimodalAdapter(Protocol):
+    async def stream_media(
+        self,
+        *,
+        prompt: str,
+        context: str,
+        model: Optional[str] = None,
+    ) -> AsyncIterator[Dict[str, Any]]:
+        """Yield progress events, then a final event with media_urls."""
+        ...
+
+
+class MultimodalStreamingBridge:
+    """Boundary-gated multimodal turn orchestrator."""
+
+    def __init__(self, adapter: Optional[MultimodalAdapter] = None) -> None:
+        self._adapter = adapter
+
+    async def run_turn(
+        self,
+        *,
+        user_message: str,
+        minimal: MinimalContext,
+        mode: NetworkBoundaryMode | str,
+        allow_multimodal: bool,
+        model: Optional[str] = None,
+    ) -> MultimodalTurnResult:
+        mode = normalize_network_mode(mode)
+        if mode != NetworkBoundaryMode.CLOUD_ALLOWED:
+            raise PermissionError(
+                f"multimodal cloud refused under NetworkBoundaryMode={mode.value!r}"
+            )
+        if not allow_multimodal:
+            raise PermissionError(
+                "multimodal cloud is disabled by hybrid policy (allow_multimodal=false)"
+            )
+        if self._adapter is None:
+            return MultimodalTurnResult(
+                user_message=user_message,
+                media_urls=[],
+                answer_text=(
+                    "[multimodal adapter not configured] "
+                    f"Would stream media grounded on {len(minimal.node_ids)} local node(s)."
+                ),
+                sent_node_ids=list(minimal.node_ids),
+                provider="none",
+                model=model or "",
+            )
+
+        urls: List[str] = []
+        notes: List[str] = []
+        async for event in self._adapter.stream_media(
+            prompt=user_message,
+            context=minimal.compact_text,
+            model=model,
+        ):
+            if not isinstance(event, dict):
+                continue
+            if event.get("media_url"):
+                urls.append(str(event["media_url"]))
+            if event.get("text"):
+                notes.append(str(event["text"]))
+        return MultimodalTurnResult(
+            user_message=user_message,
+            media_urls=urls,
+            answer_text="\n".join(notes),
+            sent_node_ids=list(minimal.node_ids),
+            provider=getattr(self._adapter, "provider_name", "multimodal"),
+            model=model or getattr(self._adapter, "default_model", ""),
+        )
+
+
+__all__ = [
+    "MultimodalTurnResult",
+    "MultimodalAdapter",
+    "MultimodalStreamingBridge",
+]