ltcai 4.4.0 → 4.5.1

package/latticeai/models/router.py

@@ -6,6 +6,7 @@ import asyncio
 import base64
 import gc
 import io
+import json
 import os
 import re
 import time
@@ -29,15 +30,28 @@ executor = ThreadPoolExecutor(max_workers=1)
 
 try:
     import mlx.core as mx
+except Exception as e:
+    mx = None
+    print(f"⚠️ MLX core unavailable: {e}")
+
+try:
     from mlx_vlm import load as vlm_load
     VLM_AVAILABLE = True
     print("✅ MLX-VLM is ready for multimodal models.")
 except Exception as e:
-    mx = None
     vlm_load = None
     VLM_AVAILABLE = False
     print(f"⚠️ MLX-VLM unavailable: {e}")
 
+try:
+    from mlx_lm import load as lm_load
+    LM_AVAILABLE = True
+    print("✅ MLX-LM is ready for text fallback models.")
+except Exception as e:
+    lm_load = None
+    LM_AVAILABLE = False
+    print(f"⚠️ MLX-LM unavailable: {e}")
+
 BRAND_NAME = "Lattice AI"
 LEGACY_BRAND_PATTERNS = [
     (re.compile(r"\bconnect\s+ai\b", re.IGNORECASE), BRAND_NAME),
@@ -236,20 +250,63 @@ def _resolve_local_hf_model(model_id: str) -> str:
         return str(local_dir)
     return model_id
 
+def _is_gemma4_model_id(model_id: str) -> bool:
+    raw = str(model_id or "").lower()
+    return bool(re.search(r"gemma[-_/ ]?4|gemma4", raw))
+
+
+def _local_model_type(path_or_model_id: str) -> Optional[str]:
+    raw = str(path_or_model_id or "").strip()
+    candidates = []
+    explicit = Path(raw).expanduser()
+    if raw and explicit.exists():
+        candidates.append(explicit / "config.json")
+    candidates.append(hf_model_dir(raw) / "config.json")
+    for config_path in candidates:
+        try:
+            if config_path.exists():
+                data = json.loads(config_path.read_text(encoding="utf-8"))
+                model_type = str(data.get("model_type") or "").strip().lower()
+                if model_type:
+                    return model_type
+        except Exception as e:
+            print(f"⚠️ Model config read skipped for {config_path}: {e}")
+    return None
+
+
 def ensure_mlx_runtime() -> None:
-    global mx, vlm_load, VLM_AVAILABLE
-    if mx is not None and vlm_load is not None:
+    global mx, vlm_load, lm_load, VLM_AVAILABLE, LM_AVAILABLE
+    if mx is not None and (vlm_load is not None or lm_load is not None):
         return
+    errors = []
     try:
         import mlx.core as mlx_core
-        from mlx_vlm import load as mlx_vlm_load
-
         mx = mlx_core
+        mx.set_default_device(mx.gpu)
+    except Exception as e:
+        errors.append(f"mlx: {e}")
+        mx = None
+
+    try:
+        from mlx_vlm import load as mlx_vlm_load
         vlm_load = mlx_vlm_load
         VLM_AVAILABLE = True
-        mx.set_default_device(mx.gpu)
     except Exception as e:
-        raise RuntimeError(f"MLX-VLM runtime is not available after install: {e}") from e
+        vlm_load = None
+        VLM_AVAILABLE = False
+        errors.append(f"mlx-vlm: {e}")
+
+    try:
+        from mlx_lm import load as mlx_lm_load
+        lm_load = mlx_lm_load
+        LM_AVAILABLE = True
+    except Exception as e:
+        lm_load = None
+        LM_AVAILABLE = False
+        errors.append(f"mlx-lm: {e}")
+
+    if mx is None or (vlm_load is None and lm_load is None):
+        raise RuntimeError(f"MLX runtime is not available after install: {'; '.join(errors)}")
 
 def _mlx_sampler(temperature: float):
     """Build an MLX sampler callable for the given temperature.
@@ -353,8 +410,8 @@ class LLMRouter:
             return self._load_cloud_model(provider, provider_model, api_key_override=api_key_override, owner=owner)
 
         ensure_mlx_runtime()
-        if mx is None or vlm_load is None:
-            raise RuntimeError("MLX-VLM is not available in this process. Run on Apple Silicon with Metal access.")
+        if mx is None or (vlm_load is None and lm_load is None):
+            raise RuntimeError("MLX is not available in this process. Run on Apple Silicon with Metal access.")
 
         cache_key = f"{model_id}_{draft_model_id}" if draft_model_id else model_id
         if cache_key in self._cache:
@@ -370,25 +427,43 @@ class LLMRouter:
         
         def _load():
             mx.set_default_device(mx.gpu)
-            print(f"🔄 Loading Target (VLM Mode): {target_model_id}...")
-            model, tokenizer = vlm_load(target_model_id)
+            is_gemma4 = _is_gemma4_model_id(model_id)
+            model_type = _local_model_type(target_model_id) or _local_model_type(model_id)
+            loader_kind = "mlx_vlm"
+
+            try:
+                if vlm_load is None:
+                    raise RuntimeError("MLX-VLM is not installed.")
+                print(f"🔄 Loading Target (VLM Mode): {target_model_id}...")
+                model, tokenizer = vlm_load(target_model_id)
+            except Exception as vlm_error:
+                if not (is_gemma4 and model_type != "gemma4_unified" and lm_load is not None):
+                    raise
+                print(f"⚠️ Gemma 4 MLX-VLM load failed; retrying MLX-LM text path: {vlm_error}")
+                print(f"🔄 Loading Target (LM Mode): {target_model_id}...")
+                model, tokenizer = lm_load(target_model_id)
+                loader_kind = "mlx_lm"
 
             draft_model = None
             if target_draft_model_id:
-                print(f"🔄 Loading Assistant (VLM Mode): {target_draft_model_id}...")
-                draft_model, _ = vlm_load(target_draft_model_id)
+                if loader_kind == "mlx_vlm":
+                    print(f"🔄 Loading Assistant (VLM Mode): {target_draft_model_id}...")
+                    draft_model, _ = vlm_load(target_draft_model_id)
+                elif lm_load is not None:
+                    print(f"🔄 Loading Assistant (LM Mode): {target_draft_model_id}...")
+                    draft_model, _ = lm_load(target_draft_model_id)
                 print("✅ Assistant Ready.")
 
-            return model, tokenizer, draft_model
+            return model, tokenizer, draft_model, loader_kind
 
         try:
             # Use the dedicated single-thread executor to ensure MLX GPU streams match during inference
-            model, tokenizer, draft_model = await loop.run_in_executor(executor, _load)
-            self._cache[cache_key] = (model, tokenizer, draft_model)
+            model, tokenizer, draft_model, loader_kind = await loop.run_in_executor(executor, _load)
+            self._cache[cache_key] = (model, tokenizer, draft_model, loader_kind)
             self._current = cache_key
             self._touch(cache_key)
-            print(f"✅ Fully Loaded: {cache_key}")
-            return f"Success: {cache_key}"
+            print(f"✅ Fully Loaded: {cache_key} ({loader_kind})")
+            return f"Success: {cache_key} ({loader_kind})"
         except Exception as e:
             print(f"❌ Load Error: {e}")
             raise e
@@ -510,6 +585,11 @@ class LLMRouter:
             print(f"⚠️ VLM chat template fallback: {e}")
             return self._build_prompt(message, context, processor)
 
+    def _unpack_local_cache(self, cached: Tuple) -> Tuple[object, object, object, str]:
+        model, tokenizer, draft_model = cached[:3]
+        loader_kind = str(cached[3]) if len(cached) > 3 else "mlx_vlm"
+        return model, tokenizer, draft_model, loader_kind
+
     async def generate_as(self, model_id: str | None, message: str, context: Optional[str] = None, max_tokens: int = 4096, temperature: float = 0.2) -> str:
         """Generate using a specific model, temporarily switching if needed. Falls back to current model if model_id is None or not loaded."""
         if not model_id or model_id == self._current:
@@ -531,16 +611,24 @@ class LLMRouter:
         if isinstance(cached, CloudModel):
             return await self._cloud_generate(cached, message, context, max_tokens, temperature)
 
-        model, tokenizer, draft_model = self._cache[self._current]
-        prompt = self._build_vlm_prompt(model, tokenizer, message, context, 1 if image_data else 0)
+        model, tokenizer, draft_model, loader_kind = self._unpack_local_cache(self._cache[self._current])
+        use_vlm = loader_kind == "mlx_vlm"
+        prompt = (
+            self._build_vlm_prompt(model, tokenizer, message, context, 1 if image_data else 0)
+            if use_vlm
+            else self._build_prompt(message, context, tokenizer)
+        )
         
         loop = asyncio.get_event_loop()
         
         def _gen():
             import mlx.core as mx
             mx.set_default_device(mx.gpu)
-            from mlx_vlm import generate as vlm_gen
-            return vlm_gen(model, tokenizer, prompt=prompt, image=self._prep_image(image_data) if image_data else None, max_tokens=max_tokens, sampler=_mlx_sampler(temperature), draft_model=draft_model, draft_kind="mtp")
+            if use_vlm:
+                from mlx_vlm import generate as vlm_gen
+                return vlm_gen(model, tokenizer, prompt=prompt, image=self._prep_image(image_data) if image_data else None, max_tokens=max_tokens, sampler=_mlx_sampler(temperature), draft_model=draft_model, draft_kind="mtp")
+            from mlx_lm import generate as lm_gen
+            return lm_gen(model, tokenizer, prompt=prompt, max_tokens=max_tokens, sampler=_mlx_sampler(temperature), draft_model=draft_model)
         result = await loop.run_in_executor(executor, _gen)
         # mlx-vlm might return a GenerationResult object; extract the text
         if hasattr(result, "text"):
@@ -577,8 +665,13 @@ class LLMRouter:
                 yield chunk
             return
 
-        model, tokenizer, draft_model = self._cache[self._current]
-        prompt = self._build_vlm_prompt(model, tokenizer, message, context, 1 if image_data else 0)
+        model, tokenizer, draft_model, loader_kind = self._unpack_local_cache(self._cache[self._current])
+        use_vlm = loader_kind == "mlx_vlm"
+        prompt = (
+            self._build_vlm_prompt(model, tokenizer, message, context, 1 if image_data else 0)
+            if use_vlm
+            else self._build_prompt(message, context, tokenizer)
+        )
         loop = asyncio.get_event_loop()
         queue = asyncio.Queue()
 
@@ -586,8 +679,12 @@ class LLMRouter:
             import mlx.core as mx
             mx.set_default_device(mx.gpu)
             try:
-                from mlx_vlm import stream_generate as vlm_stream
-                gen = vlm_stream(model, tokenizer, prompt=prompt, image=self._prep_image(image_data) if image_data else None, max_tokens=max_tokens, sampler=_mlx_sampler(temperature), draft_model=draft_model, draft_kind="mtp")
+                if use_vlm:
+                    from mlx_vlm import stream_generate as vlm_stream
+                    gen = vlm_stream(model, tokenizer, prompt=prompt, image=self._prep_image(image_data) if image_data else None, max_tokens=max_tokens, sampler=_mlx_sampler(temperature), draft_model=draft_model, draft_kind="mtp")
+                else:
+                    from mlx_lm import stream_generate as lm_stream
+                    gen = lm_stream(model, tokenizer, prompt=prompt, max_tokens=max_tokens, sampler=_mlx_sampler(temperature), draft_model=draft_model)
                 
                 for chunk in gen:
                     text = chunk.text if hasattr(chunk, "text") else (chunk[0] if isinstance(chunk, tuple) else str(chunk))
@@ -660,7 +757,7 @@ class LLMRouter:
         if isinstance(cached, CloudModel):
             return await self._cloud_generate_document(cached, message, system_prompt, max_tokens, temperature)
 
-        model, tokenizer, draft_model = cached
+        model, tokenizer, draft_model, loader_kind = self._unpack_local_cache(cached)
         if hasattr(tokenizer, "apply_chat_template"):
             try:
                 msgs = [
@@ -677,8 +774,11 @@ class LLMRouter:
         def _gen():
             import mlx.core as mx
             mx.set_default_device(mx.gpu)
-            from mlx_vlm import generate as vlm_gen
-            return vlm_gen(model, tokenizer, prompt=prompt, image=None, max_tokens=max_tokens, sampler=_mlx_sampler(temperature), draft_model=draft_model, draft_kind="mtp")
+            if loader_kind == "mlx_vlm":
+                from mlx_vlm import generate as vlm_gen
+                return vlm_gen(model, tokenizer, prompt=prompt, image=None, max_tokens=max_tokens, sampler=_mlx_sampler(temperature), draft_model=draft_model, draft_kind="mtp")
+            from mlx_lm import generate as lm_gen
+            return lm_gen(model, tokenizer, prompt=prompt, max_tokens=max_tokens, sampler=_mlx_sampler(temperature), draft_model=draft_model)
         result = await loop.run_in_executor(executor, _gen)
         if hasattr(result, "text"):
             return normalize_branding(result.text)
@@ -719,7 +819,7 @@ class LLMRouter:
                 yield chunk
             return
 
-        model, tokenizer, draft_model = cached
+        model, tokenizer, draft_model, loader_kind = self._unpack_local_cache(cached)
         if hasattr(tokenizer, "apply_chat_template"):
             try:
                 msgs = [
@@ -739,8 +839,12 @@ class LLMRouter:
             import mlx.core as mx
             mx.set_default_device(mx.gpu)
             try:
-                from mlx_vlm import stream_generate as vlm_stream
-                gen = vlm_stream(model, tokenizer, prompt=prompt, image=None, max_tokens=max_tokens, sampler=_mlx_sampler(temperature), draft_model=draft_model, draft_kind="mtp")
+                if loader_kind == "mlx_vlm":
+                    from mlx_vlm import stream_generate as vlm_stream
+                    gen = vlm_stream(model, tokenizer, prompt=prompt, image=None, max_tokens=max_tokens, sampler=_mlx_sampler(temperature), draft_model=draft_model, draft_kind="mtp")
+                else:
+                    from mlx_lm import stream_generate as lm_stream
+                    gen = lm_stream(model, tokenizer, prompt=prompt, max_tokens=max_tokens, sampler=_mlx_sampler(temperature), draft_model=draft_model)
                 for chunk in gen:
                     text = chunk.text if hasattr(chunk, "text") else (chunk[0] if isinstance(chunk, tuple) else str(chunk))
                     loop.call_soon_threadsafe(queue.put_nowait, text)

package/latticeai/services/model_catalog.py

@@ -17,8 +17,8 @@ from typing import Dict, List, Optional
 
 ENGINE_INSTALLERS = {
     "local_mlx": {
-        "command": [sys.executable, "-m", "pip", "install", "--upgrade", "mlx-vlm", "huggingface_hub[cli]"],
-        "label": "Install MLX-VLM runtime",
+        "command": [sys.executable, "-m", "pip", "install", "--upgrade", "mlx-vlm>=0.6.3", "mlx-lm", "huggingface_hub[cli]"],
+        "label": "Install MLX runtime",
     },
     "openai": {
         "command": [sys.executable, "-m", "pip", "install", "openai"],

package/latticeai/services/model_recommendation.py

@@ -18,6 +18,7 @@ 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 ─────────────────────────────────────────────────────────
@@ -85,14 +86,19 @@ def _engine_available(engine: str, profile: Dict[str, Any]) -> bool:
 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.
@@ -124,6 +130,7 @@ def _classify_one(
         "run_location": model.get("run_location"),
         "internet_requirement": model.get("internet_requirement"),
         "source_display_order": model.get("source_display_order"),
+        "runtime_compatibility": runtime,
     }
 
 
@@ -148,7 +155,7 @@ def recommend_catalog(profile: Dict[str, Any], *, engine: str = "local_mlx") ->
     ram_gb = _ram_gb(profile)
 
     classified = [
-        _classify_one(m, engine_available=engine_available, ram_gb=ram_gb)
+        _classify_one(m, engine=engine, engine_available=engine_available, ram_gb=ram_gb)
         for m in models
     ]
 

package/latticeai/services/model_runtime.py

@@ -40,6 +40,8 @@ from latticeai.core.model_compat import (
     classify_smoke_response as _classify_smoke_response,
     ensure_profile as _ensure_compat_profile,
     fast_postprocess as _compat_fast_postprocess,
+    friendly_model_runtime_error as _friendly_model_runtime_error,
+    model_runtime_compatibility as _model_runtime_compatibility,
     record_smoke_result as _record_smoke_result,
 )
 from latticeai.core.model_resolution import ModelResolution as _ModelResolution
@@ -931,7 +933,10 @@ def ensure_llamacpp_server(model_name: str) -> None:
 
 def engine_installed(engine: str) -> bool:
     if engine == "local_mlx":
-        return bool(importlib.util.find_spec("mlx") and importlib.util.find_spec("mlx_vlm"))
+        return bool(
+            importlib.util.find_spec("mlx")
+            and (importlib.util.find_spec("mlx_vlm") or importlib.util.find_spec("mlx_lm"))
+        )
     if engine == "ollama":
         return local_binary("ollama") is not None
     if engine == "vllm":
@@ -1042,7 +1047,7 @@ def engine_status() -> List[Dict]:
             "id": "local_mlx",
             "name": "MLX",
             "kind": "local",
-            "description": "Apple Silicon GPU에서 MLX/MLX-VLM 모델을 직접 실행합니다.",
+            "description": "Apple Silicon GPU에서 MLX-VLM 모델을 직접 실행하고, Gemma 4는 필요 시 MLX-LM 텍스트 경로로 재시도합니다.",
             "installed": engine_installed("local_mlx"),
             "installable": True,
             "install_label": ENGINE_INSTALLERS["local_mlx"]["label"],
@@ -1369,6 +1374,9 @@ async def prepare_and_load_model(
     parsed_provider, parsed_model = parse_model_ref(model_id)
     if parsed_provider == "mlx":
         parsed_provider = "local_mlx"
+    compatibility = _model_runtime_compatibility(parsed_model, engine=parsed_provider)
+    if compatibility.get("supported") is False:
+        raise HTTPException(status_code=400, detail=compatibility)
 
     local_engines = {"local_mlx", "ollama", "vllm", "lmstudio", "llamacpp"}
     install_result: Dict[str, object] = {}
@@ -1488,6 +1496,9 @@ async def prepare_and_load_model_stream(
     parsed_provider, parsed_model = parse_model_ref(model_id)
     if parsed_provider == "mlx":
         parsed_provider = "local_mlx"
+    compatibility = _model_runtime_compatibility(parsed_model, engine=parsed_provider)
+    if compatibility.get("supported") is False:
+        raise HTTPException(status_code=400, detail=compatibility)
 
     work_queue: "queue.Queue[Dict[str, object]]" = queue.Queue()
     work_result: Dict[str, object] = {}
@@ -1651,7 +1662,11 @@ async def prepare_and_load_model_stream(
             work_queue.put({"kind": "error", "status_code": exc.status_code, "detail": exc.detail})
         except Exception as exc:
             logging.exception("model prepare stream worker failed")
-            work_queue.put({"kind": "error", "status_code": 500, "detail": str(exc)[-2000:]})
+            work_queue.put({
+                "kind": "error",
+                "status_code": 500,
+                "detail": _friendly_model_runtime_error(exc, model_id=model_id, engine=parsed_provider),
+            })
 
     worker = threading.Thread(target=blocking_prepare, daemon=True)
     worker.start()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "4.4.0",
+  "version": "4.5.1",
   "description": "Lattice AI — local-first Digital Brain Platform (knowledge graph, durable memory, hybrid search, agents, portable encrypted brain archives)",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {

package/scripts/build_frontend_assets.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
 const repo = join(import.meta.dirname, "..");
@@ -8,6 +8,17 @@ const nestedViteManifest = join(appDir, ".vite", "asset-manifest.json");
 const publicManifest = join(appDir, "asset-manifest.json");
 const pkg = JSON.parse(readFileSync(join(repo, "package.json"), "utf8"));
 
+const assetsDir = join(appDir, "assets");
+if (existsSync(assetsDir)) {
+  for (const name of readdirSync(assetsDir)) {
+    if (!/\.(?:css|js)$/.test(name)) continue;
+    const file = join(assetsDir, name);
+    const text = readFileSync(file, "utf8");
+    const normalized = text.replace(/[ \t]+$/gm, "");
+    if (normalized !== text) writeFileSync(file, normalized, "utf8");
+  }
+}
+
 const viteManifest = existsSync(nestedViteManifest) ? nestedViteManifest : publicManifest;
 if (!existsSync(viteManifest)) {
   console.error("Vite manifest missing. Run `vite build` before build_frontend_assets.mjs.");

package/src-tauri/Cargo.lock

@@ -1654,7 +1654,7 @@ dependencies = [
 
 [[package]]
 name = "lattice-ai-desktop"
-version = "4.4.0"
+version = "4.5.1"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lattice-ai-desktop"
-version = "4.4.0"
+version = "4.5.1"
 description = "Lattice AI Digital Brain desktop shell"
 authors = ["TaeSoo Park"]
 edition = "2021"

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Lattice AI",
-  "version": "4.4.0",
+  "version": "4.5.1",
   "identifier": "ai.lattice.desktop",
   "build": {
     "beforeDevCommand": "npm run frontend:dev",

package/static/app/asset-manifest.json

@@ -1,13 +1,13 @@
 {
-  "version": "4.4.0",
+  "version": "4.5.1",
   "generated_at": "vite",
   "entrypoints": {
     "app": "/static/app/index.html"
   },
   "assets": {
     "../node_modules/@tauri-apps/api/core.js": "/static/app/assets/core-CwxXejkd.js",
-    "index.html": "/static/app/assets/index-pdzil9ac.js",
-    "assets/index-CHHal8Zl.css": "/static/app/assets/index-CHHal8Zl.css"
+    "index.html": "/static/app/assets/index-3G8qcrIS.js",
+    "assets/index-C0wYZp7k.css": "/static/app/assets/index-C0wYZp7k.css"
   },
   "vite": {
     "../node_modules/@tauri-apps/api/core.js": {
@@ -17,7 +17,7 @@
       "isDynamicEntry": true
     },
     "index.html": {
-      "file": "assets/index-pdzil9ac.js",
+      "file": "assets/index-3G8qcrIS.js",
       "name": "index",
       "src": "index.html",
       "isEntry": true,
@@ -25,7 +25,7 @@
         "../node_modules/@tauri-apps/api/core.js"
       ],
       "css": [
-        "assets/index-CHHal8Zl.css"
+        "assets/index-C0wYZp7k.css"
       ]
     }
   }