ltcai 4.3.3 → 4.5.1

package/latticeai/api/models.py

@@ -135,6 +135,8 @@ def create_models_router(
         loaded_ids: Optional[List[str]] = None,
         current_id: Optional[str] = None,
     ) -> List[Dict[str, object]]:
+        from latticeai.core.model_compat import model_runtime_compatibility
+
         engine_lookup = {str(engine.get("id") or ""): engine for engine in engines or []}
         model_lookup: Dict[str, Dict[str, object]] = {}
         for engine in engines or []:
@@ -147,30 +149,93 @@ def create_models_router(
         for item in items:
             short_id = str(item["id"]).lower()
             aliases = MODEL_ENGINE_ALIASES.get(short_id) or {}
-            options: List[Dict[str, str]] = []
+            options: List[Dict[str, object]] = []
             for engine_name in ("local_mlx", "ollama", "lmstudio", "llamacpp", "vllm"):
                 real = aliases.get(engine_name)
                 if not real:
                     continue
+                load_id = real if engine_name == "local_mlx" else f"{engine_name}:{real}"
+                engine_info = engine_lookup.get(engine_name) or {}
+                model_info = model_lookup.get(load_id) or model_lookup.get(real) or {}
+                option_loaded = load_id in loaded or real in loaded or current_id in {load_id, real}
+                option_runtime = model_runtime_compatibility(load_id, engine=engine_name)
+                option_supported = option_runtime.get("supported") is not False
+                option_pulled = bool(model_info.get("pulled"))
+                option_download_required = bool(item.get("pullable", True) and not option_pulled and not option_loaded)
                 options.append({
                     "engine": engine_name,
                     "model_id": real,
-                    "load_id": real if engine_name == "local_mlx" else f"{engine_name}:{real}",
+                    "load_id": load_id,
+                    "installed": bool(engine_info.get("installed")),
+                    "pulled": option_pulled,
+                    "loaded": option_loaded,
+                    "download_required": option_download_required,
+                    "runtime_compatibility": option_runtime,
+                    "runtime_supported": option_supported,
+                    "runtime_label": str(option_runtime.get("preferred_runtime") or engine_info.get("name") or engine_name),
                 })
             if not options:
-                options.append({"engine": "local_mlx", "model_id": item["id"], "load_id": item["id"]})
-            recommended_engine = options[0]["engine"]
-            load_id = options[0]["load_id"]
-            engine_info = engine_lookup.get(recommended_engine) or {}
-            model_info = model_lookup.get(load_id) or model_lookup.get(str(item["id"])) or {}
-            pulled = bool(model_info.get("pulled"))
-            is_loaded = load_id in loaded or str(item["id"]) in loaded or current_id in {load_id, str(item["id"])}
-            engine_installed = bool(engine_info.get("installed"))
+                raw_id = str(item["id"])
+                engine_info = engine_lookup.get("local_mlx") or {}
+                model_info = model_lookup.get(raw_id) or {}
+                option_loaded = raw_id in loaded or current_id == raw_id
+                option_pulled = bool(model_info.get("pulled"))
+                runtime_compatibility = model_runtime_compatibility(str(item["id"]), engine="local_mlx")
+                options.append({
+                    "engine": "local_mlx",
+                    "model_id": item["id"],
+                    "load_id": item["id"],
+                    "installed": bool(engine_info.get("installed")),
+                    "pulled": option_pulled,
+                    "loaded": option_loaded,
+                    "download_required": bool(item.get("pullable", True) and not option_pulled and not option_loaded),
+                    "runtime_compatibility": runtime_compatibility,
+                    "runtime_supported": runtime_compatibility.get("supported") is not False,
+                    "runtime_label": str(runtime_compatibility.get("preferred_runtime") or "MLX"),
+                })
+
+            def option_rank(option: Dict[str, object]) -> tuple[int, int, int, int]:
+                runtime_supported = bool(option.get("runtime_supported"))
+                installed = bool(option.get("installed"))
+                loaded_option = bool(option.get("loaded"))
+                ready_without_download = installed and not bool(option.get("download_required"))
+                return (
+                    0 if runtime_supported else 1,
+                    0 if loaded_option or ready_without_download else 1,
+                    0 if installed else 1,
+                    ["local_mlx", "ollama", "lmstudio", "llamacpp", "vllm"].index(str(option.get("engine") or "vllm")),
+                )
+
+            primary_option = options[0]
+            primary_compatibility = dict(primary_option.get("runtime_compatibility") or {})
+            hard_primary_statuses = {
+                "runtime_update_needed",
+                "unsupported_format",
+                "repair_model",
+                "incomplete_download",
+            }
+            selected_option = (
+                primary_option
+                if primary_compatibility.get("supported") is False
+                and primary_compatibility.get("status") in hard_primary_statuses
+                else min(options, key=option_rank)
+            )
+            recommended_engine = str(selected_option["engine"])
+            load_id = str(selected_option["load_id"])
+            model_info = model_lookup.get(load_id) or model_lookup.get(str(selected_option.get("model_id") or "")) or {}
+            pulled = bool(selected_option.get("pulled") or model_info.get("pulled"))
+            is_loaded = bool(selected_option.get("loaded"))
+            engine_installed = bool(selected_option.get("installed"))
             pullable = bool(item.get("pullable", True))
-            download_required = bool(pullable and not pulled and not is_loaded)
+            runtime_compatibility = dict(selected_option.get("runtime_compatibility") or {})
+            runtime_supported = runtime_compatibility.get("supported") is not False
+            download_required = bool(selected_option.get("download_required") and pullable and not is_loaded)
             if is_loaded:
                 load_status = "loaded"
                 unavailable_reason = None
+            elif not runtime_supported:
+                load_status = str(runtime_compatibility.get("status") or "unsupported")
+                unavailable_reason = str(runtime_compatibility.get("user_message") or "This model is not supported by the installed runtime.")
             elif not engine_installed:
                 load_status = "unavailable"
                 unavailable_reason = f"{engine_info.get('name') or recommended_engine} runtime is not installed."
@@ -196,9 +261,13 @@ def create_models_router(
                 "source_display_order": item.get("source_display_order"),
                 "pulled": pulled,
                 "download_required": download_required,
-                "load_available": is_loaded or (engine_installed and not download_required),
+                "load_available": is_loaded or (runtime_supported and engine_installed and not download_required),
                 "load_status": load_status,
                 "unavailable_reason": unavailable_reason,
+                "runtime_compatibility": runtime_compatibility,
+                "recovery_guidance": runtime_compatibility.get("recovery_guidance") or [],
+                "alternative_recommendations": runtime_compatibility.get("alternatives") or [],
+                "runtime_label": selected_option.get("runtime_label"),
             }
             base["engine_options"] = options
             base["recommended_engine"] = recommended_engine
@@ -272,10 +341,20 @@ def create_models_router(
     @router.post("/engines/prepare-model")
     async def engines_prepare_model(req: PrepareModelRequest, request: Request):
         require_user(request)
-        return await prepare_and_load_model(
-            req.model, request, engine=req.engine, user_email=req.user_email,
-            allow_download=req.allow_download,
-        )
+        try:
+            return await prepare_and_load_model(
+                req.model, request, engine=req.engine, user_email=req.user_email,
+                allow_download=req.allow_download,
+            )
+        except HTTPException:
+            raise
+        except Exception as exc:
+            from latticeai.core.model_compat import friendly_model_runtime_error
+
+            raise HTTPException(
+                status_code=500,
+                detail=friendly_model_runtime_error(exc, model_id=req.model, engine=req.engine),
+            )
 
     @router.post("/engines/prepare-model/stream")
     async def engines_prepare_model_stream(req: PrepareModelRequest, request: Request):
@@ -295,9 +374,11 @@ def create_models_router(
                 })
             except Exception as exc:
                 logging.exception("model prepare stream failed")
+                from latticeai.core.model_compat import friendly_model_runtime_error
+
                 yield sse_event("error", {
                     "status_code": 500,
-                    "detail": str(exc)[-1000:] or "모델 준비에 실패했습니다.",
+                    "detail": friendly_model_runtime_error(exc, model_id=req.model, engine=req.engine),
                 })
 
         return StreamingResponse(
@@ -356,6 +437,8 @@ def create_models_router(
     @router.post("/models/load")
     async def load_model(req: LoadModelRequest, request: Request):
         try:
+            from latticeai.core.model_compat import friendly_model_runtime_error, model_runtime_compatibility
+
             model_id = req.model_id
             requested_engine = req.engine or (model_id.split(":", 1)[0] if ":" in model_id else "local_mlx")
             if IS_PUBLIC_MODE and not ALLOW_LOCAL_MODELS and requested_engine in {"local_mlx", "mlx"}:
@@ -363,6 +446,9 @@ def create_models_router(
                     status_code=400,
                     detail="Public mode blocks local MLX model loading. Use openai:, openrouter:, groq:, together:, or set LATTICEAI_ALLOW_LOCAL_MODELS=true.",
                 )
+            compatibility = model_runtime_compatibility(model_id, engine=requested_engine)
+            if compatibility.get("supported") is False:
+                raise HTTPException(status_code=400, detail=compatibility)
             return await prepare_and_load_model(
                 model_id, request, engine=req.engine, user_email=req.user_email,
                 adapter_path=req.adapter_path, draft_model_id=req.draft_model_id,
@@ -371,7 +457,10 @@ def create_models_router(
         except HTTPException:
             raise
         except Exception as e:
-            raise HTTPException(status_code=500, detail=str(e))
+            raise HTTPException(
+                status_code=500,
+                detail=friendly_model_runtime_error(e, model_id=req.model_id, engine=req.engine),
+            )
 
     @router.post("/models/switch/{model_id:path}")
     async def switch_model(model_id: str, request: Request):

package/latticeai/api/tools.py

@@ -15,7 +15,7 @@ from pydantic import BaseModel
 
 from latticeai.api.computer_use import create_computer_use_router
 from latticeai.api.local_files import create_local_files_router
-from latticeai.core.hooks import dispatch_tool
+from lattice_brain.runtime.hooks import dispatch_tool
 from latticeai.api.mcp import create_mcp_router
 from latticeai.api.permissions import create_permissions_router
 from latticeai.services.upload_service import process_uploaded_document

package/latticeai/api/workflow_designer.py

@@ -1,7 +1,7 @@
 """Workflow Designer API router (v2).
 
 Create / edit / validate / execute / inspect / export / import workflows plus
-run history, layered on :mod:`latticeai.core.workflow_engine` and the existing
+run history, layered on :mod:`lattice_brain.workflow` and the existing
 ``WorkspaceOSStore`` workflow persistence (so pre-2.0 workflow history is
 preserved). Paths are namespaced under ``/workflows`` to avoid colliding with
 ``/workspace/workflows``.
@@ -67,7 +67,7 @@ def create_workflow_designer_router(
     run_executor: Any = None,
     trigger_service: Any = None,
 ) -> APIRouter:
-    from latticeai.core.workflow_engine import (
+    from lattice_brain.workflow import (
         WorkflowEngine,
         validate_definition,
         export_workflow,

package/latticeai/app_factory.py

@@ -110,7 +110,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     from latticeai.services.chat_service import ChatService
     from latticeai.services.search_service import SearchService
     from latticeai.core.embedding_providers import resolve_embedder, resolve_embedding_profile
-    from latticeai.services.agent_runtime import AgentRuntime
+    from lattice_brain.runtime.agent_runtime import AgentRuntime
     from latticeai.services.model_runtime import (
         CLOUD_VERIFY_TTL_SECONDS,
         ENGINE_MODEL_CATALOG,
@@ -152,7 +152,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     from latticeai.api.garden import create_garden_router
     from latticeai.api.setup import create_setup_router
     from latticeai.api.hooks import create_hooks_router
-    from latticeai.core.hooks import HooksRegistry
+    from lattice_brain.runtime.hooks import HooksRegistry
     from latticeai.core.builtin_hooks import register_builtin_hook_runners
     from latticeai.core.product_hardening import build_product_hardening_status
     from latticeai.api.agent_registry import create_agent_registry_router
@@ -161,7 +161,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     from latticeai.api.browser import create_browser_router
     from latticeai.api.portability import create_portability_router
     from latticeai.services.memory_service import MemoryService
-    from latticeai.services.ingestion import IngestionItem, IngestionPipeline
+    from lattice_brain.ingestion import IngestionItem, IngestionPipeline
     from lattice_brain import BrainCore, ConversationStore
     from lattice_brain.storage import storage_from_env
     from lattice_brain.context import ContextAssembler
@@ -169,7 +169,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     from lattice_brain.identity import DeviceIdentity
     from lattice_brain.network import BrainNetwork
     from latticeai.api.network import create_network_router
-    from latticeai.services.kg_portability import KGPortabilityService
+    from lattice_brain.portability import KGPortabilityService
     # The aliased names below look unused but are part of the legacy
     # ``server_app`` attribute surface: every local is exported via
     # ``dict(locals())`` and reached through ``server_app.__getattr__``

package/latticeai/brain/__init__.py

@@ -1,10 +1,28 @@
-"""Compatibility namespace for the standalone :mod:`lattice_brain` package."""
+"""Deprecated compatibility namespace for the standalone :mod:`lattice_brain` package.
 
-from lattice_brain.core import BrainCore, BrainCoreConfig
-from latticeai.brain.context import AssembledContext, ContextAssembler, ContextSection
-from latticeai.brain.conversations import ConversationStore
-from latticeai.brain.memory import BrainMemory
-from latticeai.brain.store import KnowledgeGraphStore
+The Brain Core implementation physically lives in ``lattice_brain`` as of
+v4.4.0. This package only re-exports the public surface for older imports;
+new code must import ``lattice_brain`` directly.
+"""
+
+import warnings
+
+from lattice_brain import (
+    AssembledContext,
+    BrainCore,
+    BrainCoreConfig,
+    BrainMemory,
+    ContextAssembler,
+    ContextSection,
+    ConversationStore,
+    KnowledgeGraphStore,
+)
+
+warnings.warn(
+    "latticeai.brain is deprecated; import lattice_brain instead",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
 __all__ = [
     "AssembledContext",