ltcai 10.7.0 → 10.9.0

package/latticeai/api/setup.py

@@ -9,6 +9,7 @@ from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
 from lattice_brain.ingestion import IngestionItem
+from latticeai.core.messages import http_error, resolve_language
 from latticeai.models.router import parse_model_ref
 from latticeai.services.process_audit import command_plan
 from latticeai.setup.auto_setup import (
@@ -184,27 +185,25 @@ def create_setup_router(
         }
         url = auth_urls.get(mcp_id)
         if not url:
-            raise HTTPException(status_code=404, detail=f"알 수 없는 MCP: {mcp_id}")
+            raise http_error(404, "mcp.unknown_id", resolve_language(request), mcp_id=mcp_id)
         open_url(url)
         return {"status": "ok", "opened": url, "mcp_id": mcp_id}
     
     
     # ── First Value Loop demo corpus (backlog #3, review §3.3 P0) ────────────
 
-    def _require_demo_pipeline():
+    def _require_demo_pipeline(request: Request):
         if ingestion_pipeline is None or not ingestion_pipeline.available():
-            raise HTTPException(
-                status_code=503, detail="Knowledge Graph ingestion is disabled.",
-            )
+            raise http_error(503, "capture.ingestion_disabled", resolve_language(request))
         if knowledge_graph is None:
-            raise HTTPException(status_code=503, detail="Knowledge Graph is disabled.")
+            raise http_error(503, "common.graph_disabled", resolve_language(request))
 
     def _demo_workspace(request: Request, body_workspace: Optional[str], user: str) -> Optional[str]:
         header = request.headers.get("X-Workspace-Id")
         header = header.strip() if header and header.strip() else None
         supplied = [value for value in (body_workspace, header) if value]
         if len(set(supplied)) > 1:
-            raise HTTPException(status_code=403, detail="Workspace selectors must match.")
+            raise http_error(403, "common.workspace_mismatch", resolve_language(request))
         requested = supplied[0] if supplied else None
         if workspace_service is None:
             return requested
@@ -217,7 +216,7 @@ def create_setup_router(
     async def demo_corpus_status(request: Request):
         """Whether the demo corpus is installed + the suggestion chips."""
         require_user(request)
-        _require_demo_pipeline()
+        _require_demo_pipeline(request)
         installed = knowledge_graph.find_documents_by_uri_prefix(DEMO_URI_PREFIX)
         return {
             "installed": bool(installed),
@@ -236,7 +235,7 @@ def create_setup_router(
         instead of duplicating.
         """
         user = require_user(request)
-        _require_demo_pipeline()
+        _require_demo_pipeline(request)
         workspace_id = _demo_workspace(request, req.workspace_id if req else None, user)
         results = []
         ingested = 0
@@ -285,7 +284,7 @@ def create_setup_router(
     async def demo_corpus_remove(request: Request):
         """Remove every demo document (node + chunks + edges + orphan source)."""
         require_user(request)
-        _require_demo_pipeline()
+        _require_demo_pipeline(request)
         installed = knowledge_graph.find_documents_by_uri_prefix(DEMO_URI_PREFIX)
         removed = []
         for doc in installed:
@@ -314,7 +313,7 @@ def create_setup_router(
         }
         url = urls.get(permission_id)
         if not url:
-            raise HTTPException(status_code=404, detail="알 수 없는 권한 설정입니다.")
+            raise http_error(404, "setup.unknown_permission", resolve_language(request))
         open_url(url)
         return {"status": "ok", "opened": url, "permission": permission_id}
     return api_router

package/latticeai/api/static_routes.py

@@ -2,8 +2,10 @@
 
 from __future__ import annotations
 
+import asyncio
 import hashlib
 import hmac
+import re
 import secrets
 import subprocess
 import time
@@ -40,6 +42,59 @@ SYSINFO_READINESS_ROOMY_MAX = 55.0
 SYSINFO_READINESS_TIGHT_MAX = 80.0
 
 
+def _probe_host_capacity() -> Dict[str, Any]:
+    """Sample CPU / RAM / GPU on this machine. Blocking — call off the loop.
+
+    Extracted from the route so the subprocess sampling can be handed to a
+    worker thread, and so the parsing is testable without an HTTP request.
+    """
+    result: Dict[str, Any] = {
+        "cpu_pct": 0.0,
+        "ram_pct": 0.0,
+        "gpu_mem_pct": 0.0,
+        "gpu_mem_gb": 0.0,
+        "readiness": "roomy",
+    }
+    try:
+        # CPU
+        top_out = subprocess.run(["top", "-l", "1", "-n", "0"], capture_output=True, text=True, timeout=4).stdout
+        for line in top_out.splitlines():
+            if "CPU usage" in line:
+                m = re.search(r"([\d.]+)% user.*?([\d.]+)% sys", line)
+                if m:
+                    result["cpu_pct"] = round(float(m.group(1)) + float(m.group(2)), 1)
+        # RAM
+        vm_out = subprocess.run(["vm_stat"], capture_output=True, text=True, timeout=4).stdout
+        pages: dict = {}
+        for line in vm_out.splitlines():
+            for key in ["Pages free", "Pages active", "Pages inactive", "Pages wired down", "Pages occupied by compressor"]:
+                if line.startswith(key):
+                    m = re.search(r"(\d+)", line)
+                    if m:
+                        pages[key] = int(m.group(1))
+        total = sum(pages.values())
+        used = total - pages.get("Pages free", 0)
+        result["ram_pct"] = round(used / total * 100, 1) if total else 0.0
+        # GPU (MLX / Apple Silicon unified memory)
+        try:
+            import mlx.core as _mx
+            hw_out = subprocess.run(["sysctl", "-n", "hw.memsize"], capture_output=True, text=True, timeout=2).stdout
+            total_bytes = int(hw_out.strip())
+            gpu_bytes = _mx.get_active_memory() + _mx.get_cache_memory()
+            result["gpu_mem_gb"] = round(gpu_bytes / (1024 ** 3), 2)
+            result["gpu_mem_pct"] = round(gpu_bytes / total_bytes * 100, 1) if total_bytes else 0.0
+        except Exception:
+            quiet()
+    except Exception as e:
+        result["error"] = str(e)
+    result["readiness"] = host_capacity_readiness(
+        cpu_pct=float(result.get("cpu_pct") or 0.0),
+        ram_pct=float(result.get("ram_pct") or 0.0),
+        gpu_mem_pct=float(result.get("gpu_mem_pct") or 0.0),
+    )
+    return result
+
+
 def host_capacity_readiness(
     *,
     cpu_pct: float = 0.0,
@@ -278,54 +333,15 @@ def create_static_routes_router(
 
         ``readiness`` is ``roomy`` | ``tight`` | ``low`` so basic System copy
         does not re-interpret raw percents on the client.
+
+        The probe itself is three subprocesses — ``top -l 1`` alone samples for
+        about a second — so it runs on a worker thread. Run inline it held the
+        event loop for the whole sample, and this route is hit on the System
+        screen *and* during first-run analysis, i.e. exactly while an answer is
+        streaming: one status poll used to stall every open stream.
         """
         require_user(request)
-        import re as _re
-        result: Dict[str, Any] = {
-            "cpu_pct": 0.0,
-            "ram_pct": 0.0,
-            "gpu_mem_pct": 0.0,
-            "gpu_mem_gb": 0.0,
-            "readiness": "roomy",
-        }
-        try:
-            # CPU
-            top_out = subprocess.run(["top", "-l", "1", "-n", "0"], capture_output=True, text=True, timeout=4).stdout
-            for line in top_out.splitlines():
-                if "CPU usage" in line:
-                    m = _re.search(r"([\d.]+)% user.*?([\d.]+)% sys", line)
-                    if m:
-                        result["cpu_pct"] = round(float(m.group(1)) + float(m.group(2)), 1)
-            # RAM
-            vm_out = subprocess.run(["vm_stat"], capture_output=True, text=True, timeout=4).stdout
-            pages: dict = {}
-            for line in vm_out.splitlines():
-                for key in ["Pages free", "Pages active", "Pages inactive", "Pages wired down", "Pages occupied by compressor"]:
-                    if line.startswith(key):
-                        m = _re.search(r"(\d+)", line)
-                        if m:
-                            pages[key] = int(m.group(1))
-            total = sum(pages.values())
-            used  = total - pages.get("Pages free", 0)
-            result["ram_pct"] = round(used / total * 100, 1) if total else 0.0
-            # GPU (MLX / Apple Silicon unified memory)
-            try:
-                import mlx.core as _mx
-                hw_out = subprocess.run(["sysctl", "-n", "hw.memsize"], capture_output=True, text=True, timeout=2).stdout
-                total_bytes = int(hw_out.strip())
-                gpu_bytes = _mx.get_active_memory() + _mx.get_cache_memory()
-                result["gpu_mem_gb"]  = round(gpu_bytes / (1024 ** 3), 2)
-                result["gpu_mem_pct"] = round(gpu_bytes / total_bytes * 100, 1) if total_bytes else 0.0
-            except Exception:
-                quiet()
-        except Exception as e:
-            result["error"] = str(e)
-        result["readiness"] = host_capacity_readiness(
-            cpu_pct=float(result.get("cpu_pct") or 0.0),
-            ram_pct=float(result.get("ram_pct") or 0.0),
-            gpu_mem_pct=float(result.get("gpu_mem_pct") or 0.0),
-        )
-        return result
+        return await asyncio.to_thread(_probe_host_capacity)
 
     return StaticRoutesBundle(
         api_router,

package/latticeai/api/tools.py

@@ -19,6 +19,7 @@ from latticeai.api.computer_use import create_computer_use_router
 from latticeai.api.local_files import create_local_files_router
 from latticeai.api.mcp import create_mcp_router
 from latticeai.api.permissions import create_permissions_router
+from latticeai.core.messages import http_error, resolve_language
 from latticeai.services.router_context import ToolRouterContext
 from latticeai.services.tool_dispatch import (
     TOOL_GOVERNANCE,
@@ -510,7 +511,7 @@ def create_tools_router(
         )
         target = Path(path).expanduser().resolve()
         if not target.exists() or not target.is_file():
-            raise HTTPException(status_code=404, detail="File not found")
+            raise http_error(404, "common.file_not_found", resolve_language(request))
         import pypdfium2 as pdfium
         doc = None
         try:
@@ -527,7 +528,7 @@ def create_tools_router(
                 pages.append({"page": i + 1, "b64": b64})
             return {"total": total, "pages": pages}
         except Exception as e:
-            raise HTTPException(status_code=500, detail=f"PDF 렌더링 실패: {e}")
+            raise http_error(500, "tools.pdf_render_failed", resolve_language(request), reason=e)
         finally:
             if doc is not None:
                 try:
@@ -544,9 +545,9 @@ def create_tools_router(
         rel = unquote(path).lstrip("/")
         target = (AGENT_ROOT / rel).resolve()
         if AGENT_ROOT not in target.parents and target != AGENT_ROOT:
-            raise HTTPException(status_code=403, detail="경로가 작업 공간 밖입니다.")
+            raise http_error(403, "tools.path_outside_workspace", resolve_language(request))
         if not target.exists() or not target.is_file():
-            raise HTTPException(status_code=404, detail="파일이 없습니다.")
+            raise http_error(404, "common.file_not_found", resolve_language(request))
         return FileResponse(
             path=target,
             filename=target.name,
@@ -570,9 +571,9 @@ def create_tools_router(
         rel = unquote(path).lstrip("/")
         target = (AGENT_ROOT / rel).resolve()
         if AGENT_ROOT not in target.parents and target != AGENT_ROOT:
-            raise HTTPException(status_code=403, detail="경로가 작업 공간 밖입니다.")
+            raise http_error(403, "tools.path_outside_workspace", resolve_language(request))
         if not target.exists() or not target.is_dir():
-            raise HTTPException(status_code=404, detail="디렉터리가 없습니다.")
+            raise http_error(404, "tools.directory_not_found", resolve_language(request))
         try:
             payload, filename = zip_workspace_dir(rel)
         except ToolError as exc:

package/latticeai/core/file_generation.py

@@ -312,9 +312,54 @@ def validate_file_content(content: str, target_path: str) -> Tuple[bool, str]:
         if "```" in content:
             return False, "output still contains Markdown fences"
         return True, "ok"
+    # Prose types (.md, .txt, .csv, …) have no grammar to check, which used to
+    # mean *nothing* was checked: a 1–4B model that answered "Sure! Here is the
+    # document you asked for:" and stopped had its sentence saved as the file,
+    # because the fence stripper only removes conversational lines it can
+    # recognise and the length guard on `looks_like_refusal` lets a wordy
+    # refusal through. The two checks below are the only ones that generalise
+    # without inventing a grammar: it must not still be wearing fences, and it
+    # must not be *only* an answer about the file.
+    if "```" in content:
+        return False, "output still contains Markdown fences"
+    if _looks_like_commentary(content):
+        return False, "the reply talks about the file instead of being the file"
     return True, "ok"
 
 
+# Openers that mean "I am about to give you the thing" — if the whole reply is
+# one of these, the thing never arrived.
+_COMMENTARY_RE = re.compile(
+    r"^\s*("
+    r"(sure|of course|certainly|okay|ok|alright|here|below|the following)\b"
+    r"|i('ve| have| will|'ll)\b"
+    r"|(물론|네[,!. ]|알겠|다음은|아래(는|의)?|요청하신|원하시는)"
+    r")",
+    re.IGNORECASE,
+)
+
+
+def _looks_like_commentary(content: str) -> bool:
+    """True when the reply reads as an answer *about* a file, not the file.
+
+    Deliberately conservative — a long document that merely opens with "The
+    following" is a document. Only a short reply that both opens
+    conversationally and never grows into content is rejected, so a real file
+    is never thrown away to catch a chat line.
+    """
+    stripped = content.strip()
+    if len(stripped) > 400:
+        return False
+    if not _COMMENTARY_RE.match(stripped):
+        return False
+    # Structure means content arrived after the preamble: a heading, a list, a
+    # table row, a delimiter, or simply several lines of body text.
+    body = stripped.split("\n", 1)[1].strip() if "\n" in stripped else ""
+    if re.search(r"^\s*(#{1,6}\s|[-*+]\s|\d+[.)]\s|\||>)", body, re.MULTILINE):
+        return False
+    return len(body) < 120
+
+
 # ── prompting ───────────────────────────────────────────────────────────
 
 _FIRST_LINE_HINTS: Dict[str, str] = {
@@ -869,14 +914,28 @@ async def generate_file_content(
     """Generate validated file content with any LLM.
 
     ``generate`` is an async callable ``context -> raw model text``. Runs up
-    to ``max_attempts`` model calls (the second with corrective feedback),
+    to ``max_attempts`` model calls (each retry carrying corrective feedback),
     then falls back to deterministic repair, so the returned content is
     always non-empty and structurally valid for the target type.
+
+    One extra call beyond ``max_attempts`` is spent — at most once per
+    request — when the model has returned a byte-identical rejected reply.
+    That is the one case where the ordinary retry is known to be dead on
+    arrival: the corrective feedback did not change the reply, so the budget
+    is better spent on a prompt that names the repetition than on a third
+    identical round trip. Small local models hit this constantly; large ones
+    never do, so the extra call is not charged to models that do not need it.
     """
     attempts: List[Dict[str, Any]] = []
     feedback: Optional[str] = None
-    last_candidate = ""
-    for attempt in range(1, max_attempts + 1):
+    best_candidate = ""
+    best_score = (-1, -1)
+    seen: set[str] = set()
+    escalations_left = 1
+    attempt = 0
+    budget = max_attempts
+    while attempt < budget:
+        attempt += 1
         context = build_file_generation_context(
             target_path, user_request, feedback=feedback, bundle_files=bundle_files,
         )
@@ -888,16 +947,90 @@ async def generate_file_content(
             continue
         candidate = extract_file_content(str(raw or ""), target_path)
         ok, reason = validate_file_content(candidate, target_path)
-        attempts.append({"attempt": attempt, "valid": ok, "reason": reason})
+        record: Dict[str, Any] = {"attempt": attempt, "valid": ok, "reason": reason}
         if ok:
+            attempts.append(record)
             return candidate, {"attempts": attempts, "repaired": False}
-        if len(candidate) > len(last_candidate):
-            last_candidate = candidate
-        feedback = reason
-    repaired = repair_file_content(last_candidate, target_path, user_request)
+
+        # A small model handed the same corrective feedback often replays the
+        # same reply verbatim. Saying "you sent this before" is the only signal
+        # left that has any chance of moving it, and it makes the wasted retry
+        # visible in the trace instead of looking like two genuine tries.
+        fingerprint = candidate.strip()
+        repeated = fingerprint in seen and bool(fingerprint)
+        record["repeated"] = repeated
+        seen.add(fingerprint)
+        if repeated and escalations_left and attempt >= budget:
+            # The retry budget is exhausted and the last thing it bought was a
+            # duplicate. Buy one more, but only with a prompt that says so.
+            escalations_left -= 1
+            budget += 1
+            record["escalated"] = True
+        attempts.append(record)
+
+        # Keep the candidate that is *closest to a file*, not the longest one.
+        # Longest-wins handed repair a 900-character apology in preference to a
+        # 300-character HTML document that only needed its </html> closing —
+        # and repair can finish the document but can only bury the apology.
+        score = _salvage_score(candidate, target_path)
+        if score > best_score:
+            best_score, best_candidate = score, candidate
+
+        feedback = (
+            f"{reason}. You already sent exactly this reply and it was rejected "
+            "for the same reason — do not repeat it. Output the file itself, "
+            "starting at its first character."
+            if repeated else reason
+        )
+    repaired = repair_file_content(best_candidate, target_path, user_request)
     return repaired, {"attempts": attempts, "repaired": True}
 
 
+def _salvage_score(candidate: str, target_path: str) -> Tuple[int, int]:
+    """How useful an invalid candidate is as raw material for repair.
+
+    ``(tier, length)`` — tier first, so a short real document always beats a
+    long non-document; length breaks ties within a tier.
+
+    Tier 2  something of the right shape that repair can finish (an HTML
+            document missing its close tag, parseable-ish JSON, Python that
+            at least tokenises).
+    Tier 1  ordinary text: no structure, but the words may be the content.
+    Tier 0  a refusal — repair should prefer literally anything else, because
+            an apology written into the file is worse than an empty stub.
+    """
+    text = candidate.strip()
+    if not text:
+        return (0, 0)
+    if looks_like_refusal(text):
+        return (0, len(text))
+
+    ext = _ext(target_path)
+    lower = text.lower()
+    if ext in (".html", ".htm"):
+        if lower.startswith("<!doctype") or lower.startswith("<html"):
+            return (2, len(text))
+    elif ext == ".json":
+        if _slice_json_document(text) is not None:
+            return (2, len(text))
+    elif ext == ".py":
+        try:
+            ast.parse(text)
+        except SyntaxError:
+            pass
+        else:
+            return (2, len(text))
+    elif ext in _BRACED_CODE_EXTENSIONS:
+        if _check_balanced_delimiters(text)[0]:
+            return (2, len(text))
+    elif ext in _COMPONENT_EXTENSIONS:
+        if _check_component_blocks(text)[0]:
+            return (2, len(text))
+    elif ext == ".css" and "{" in text and "}" in text:
+        return (2, len(text))
+    return (1, len(text))
+
+
 __all__ = [
     "PREVIEWABLE_EXTENSIONS",
     "build_file_generation_context",

package/latticeai/core/legacy_compatibility.py

@@ -13,7 +13,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, List
 
-LEGACY_COMPATIBILITY_VERSION = "10.7.0"
+LEGACY_COMPATIBILITY_VERSION = "10.9.0"
 
 
 @dataclass(frozen=True)

package/latticeai/core/marketplace.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
-MARKETPLACE_VERSION = "10.7.0"
+MARKETPLACE_VERSION = "10.9.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent", "ingestion_bridge")
 
 

package/latticeai/core/mcp_registry.py

@@ -4,6 +4,7 @@ Lattice AI — MCP Registry data & pure helper functions.
 Extracted from server.py to reduce module size.
 """
 
+import asyncio
 import json
 import logging
 import os
@@ -354,6 +355,13 @@ async def install_skill(plugin: str, skill: str) -> Dict:
     }
 
 
+def _run_installer(command: List[str], timeout: int) -> "subprocess.CompletedProcess[str]":
+    """Run one package-installer command. Blocking — call off the event loop."""
+    return subprocess.run(
+        command, capture_output=True, text=True, timeout=timeout, check=False
+    )
+
+
 def create_mcp_install_state(data_dir: Path) -> Dict[str, Callable]:
     """Return bound MCP state helpers for given data_dir. No global side effects."""
     MCP_FILE = Path(data_dir) / "mcp_installs.json"
@@ -445,11 +453,15 @@ def create_mcp_install_state(data_dir: Path) -> Dict[str, Callable]:
             status = "needs_auth"
             message = "커넥터 인증이 필요합니다. Codex 앱의 connector 설정에서 계정을 연결하면 바로 사용할 수 있습니다."
         elif item.get("install_mode") == "pip":
+            # Package installers are minutes of network I/O. On the event loop
+            # they froze every other request for the whole install; each one now
+            # runs on a worker thread instead.
             packages = item.get("pip_packages") or []
             for pkg in packages:
-                completed = subprocess.run(
+                completed = await asyncio.to_thread(
+                    _run_installer,
                     [sys.executable, "-m", "pip", "install", "--upgrade", pkg],
-                    capture_output=True, text=True, timeout=900, check=False,
+                    900,
                 )
                 if completed.returncode != 0:
                     raise HTTPException(status_code=500, detail=(completed.stderr or "")[-2000:] or f"{pkg} 설치 실패")
@@ -458,7 +470,9 @@ def create_mcp_install_state(data_dir: Path) -> Dict[str, Callable]:
             pkg = item.get("package", "")
             version = item.get("package_version")
             pkg_str = f"{pkg}=={version}" if version else pkg
-            completed = subprocess.run([sys.executable, "-m", "pip", "install", pkg_str], capture_output=True, text=True, timeout=300, check=False)
+            completed = await asyncio.to_thread(
+                _run_installer, [sys.executable, "-m", "pip", "install", pkg_str], 300
+            )
             if completed.returncode != 0:
                 raise HTTPException(status_code=500, detail=(completed.stderr or "")[-2000:] or f"{pkg} 설치 실패")
             message = f"pip 패키지 설치 완료: {pkg_str}"
@@ -466,7 +480,9 @@ def create_mcp_install_state(data_dir: Path) -> Dict[str, Callable]:
             pkg = item.get("package", "")
             version = item.get("package_version")
             pkg_str = f"{pkg}@{version}" if version else pkg
-            completed = subprocess.run(["npm", "install", "-g", pkg_str], capture_output=True, text=True, timeout=300, check=False)
+            completed = await asyncio.to_thread(
+                _run_installer, ["npm", "install", "-g", pkg_str], 300
+            )
             if completed.returncode != 0:
                 raise HTTPException(status_code=500, detail=(completed.stderr or "")[-2000:] or f"{pkg} 설치 실패")
             message = f"npm 패키지 설치 완료: {pkg_str}"