ltcai 10.7.0 → 10.8.0

package/latticeai/api/auth.py

@@ -9,10 +9,11 @@ from dataclasses import dataclass
 from typing import Any, Awaitable, Callable, Dict, Optional
 from urllib.parse import urlencode
 
-from fastapi import APIRouter, HTTPException, Request
+from fastapi import APIRouter, Request
 from fastapi.responses import JSONResponse, RedirectResponse
 from pydantic import BaseModel
 
+from latticeai.core.messages import DEFAULT_LANGUAGE, http_error, resolve_language
 from latticeai.core.oidc import (
     OIDCValidationError,
 )
@@ -92,18 +93,16 @@ def create_auth_router(
 ) -> APIRouter:
     router = APIRouter()
 
-    def _enforce_password_policy(password: str) -> None:
+    def _enforce_password_policy(password: str, language: str = DEFAULT_LANGUAGE) -> None:
         # Real policy (v4): length >= 8 with letters AND digits. A 4-char
         # minimum was not a policy.
         pw = str(password or "")
         if len(pw) < 8 or not any(c.isalpha() for c in pw) or not any(c.isdigit() for c in pw):
-            raise HTTPException(
-                status_code=400,
-                detail="비밀번호는 8자 이상이며 영문자와 숫자를 모두 포함해야 합니다.",
-            )
+            raise http_error(400, "auth.password_too_weak", language)
 
     @router.post("/register")
     async def register(req: UserRegister, request: Request):
+        lang = resolve_language(request)
         check_ip_rate_limit(client_ip(request), "register", max_calls=5, window_secs=3600)
         invite_claim = bool(
             invite_gate_enabled
@@ -111,19 +110,16 @@ def create_auth_router(
             and invite_authorized(request)
         )
         if invite_gate_enabled and not invite_claim:
-            raise HTTPException(
-                status_code=403,
-                detail="유효한 서명 초대 권한이 필요합니다.",
-            )
+            raise http_error(403, "auth.invitation_required", lang)
         # Closed public registration stays closed unless the operator enabled
         # the invite gate and this exact request carries a valid signed claim.
         if not open_registration and not invite_claim:
-            raise HTTPException(status_code=403, detail="회원가입이 비활성화되어 있습니다. 관리자에게 문의하세요.")
-        _enforce_password_policy(req.password)
+            raise http_error(403, "auth.registration_disabled", lang)
+        _enforce_password_policy(req.password, lang)
         email = normalize_email(req.email)
         users = load_users()
         if email in users:
-            raise HTTPException(status_code=400, detail="이미 존재하는 이메일입니다.")
+            raise http_error(400, "auth.email_taken", lang)
         role = "admin" if not users else "user"
         users[email] = {
             "password": hash_password(req.password),
@@ -140,14 +136,15 @@ def create_auth_router(
 
     @router.post("/login")
     async def login(req: UserLogin, request: Request):
+        lang = resolve_language(request)
         check_ip_rate_limit(client_ip(request), "login", max_calls=10, window_secs=300)
         email = normalize_email(req.email)
         users = load_users()
         user = users.get(email)
         if not user or not verify_and_migrate(email, req.password, user.get("password", ""), users):
-            raise HTTPException(status_code=401, detail="이메일 또는 비밀번호가 틀렸습니다.")
+            raise http_error(401, "auth.bad_credentials", lang)
         if user.get("disabled"):
-            raise HTTPException(status_code=403, detail="비활성화된 계정입니다.")
+            raise http_error(403, "auth.account_disabled", lang)
         role = get_user_role(email, users)
         token = create_session(email)
         response = JSONResponse(content={
@@ -174,10 +171,11 @@ def create_auth_router(
 
     @router.get("/auth/sso/login")
     async def sso_login(request: Request):
+        lang = resolve_language(request)
         settings = get_sso_settings()
         discovery = await get_sso_discovery()
         if not settings.get("enabled") or not discovery:
-            raise HTTPException(status_code=503, detail="SSO가 설정되지 않았습니다.")
+            raise http_error(503, "sso.not_configured", lang)
         state = secrets.token_urlsafe(16)
         nonce = secrets.token_urlsafe(16)
         # PKCE (S256): bind the token exchange to this login, so an
@@ -214,16 +212,17 @@ def create_auth_router(
         return RedirectResponse(f"{discovery['authorization_endpoint']}?{params}")
 
     @router.get("/auth/sso/callback")
-    async def sso_callback(code: str = "", state: str = "", error: str = ""):
+    async def sso_callback(request: Request, code: str = "", state: str = "", error: str = ""):
+        lang = resolve_language(request)
         entry = _sso_states.pop(state, None)
         if entry is None or time.time() - entry.issued_at > 300:
-            raise HTTPException(status_code=400, detail="유효하지 않은 SSO 상태입니다.")
+            raise http_error(400, "sso.invalid_state", lang)
         if error:
             return RedirectResponse(f"/?{urlencode({'sso_error': error})}")
         settings = get_sso_settings()
         discovery = await get_sso_discovery()
         if not settings.get("enabled") or not discovery:
-            raise HTTPException(status_code=503, detail="SSO 설정 오류입니다.")
+            raise http_error(503, "sso.config_error", lang)
         import httpx as _httpx
         async with _httpx.AsyncClient() as c:
             r = await c.post(discovery["token_endpoint"], data={
@@ -237,7 +236,7 @@ def create_auth_router(
             tokens = r.json()
         id_token = tokens.get("id_token")
         if not id_token:
-            raise HTTPException(status_code=400, detail="ID 토큰을 받지 못했습니다.")
+            raise http_error(400, "sso.no_id_token", lang)
         # Never trust a decoded JWT payload: verify signature (against the
         # provider JWKS), issuer, audience, expiry and the login nonce before
         # using any claim. Any failure is fail-closed (401).
@@ -253,20 +252,17 @@ def create_auth_router(
             )
         except OIDCValidationError as exc:
             logging.warning("SSO ID token rejected: %s", exc)
-            raise HTTPException(status_code=401, detail="SSO 토큰 검증에 실패했습니다.")
+            raise http_error(401, "sso.token_verification_failed", lang)
         except Exception as exc:  # discovery/JWKS fetch failure → fail closed
             logging.warning("SSO token validation error: %s", exc)
-            raise HTTPException(status_code=502, detail="SSO 공급자 검증에 실패했습니다.")
+            raise http_error(502, "sso.provider_verification_failed", lang)
         email = normalize_email(payload.get("email") or payload.get("preferred_username") or payload.get("upn") or "")
         if not email:
-            raise HTTPException(status_code=400, detail="이메일을 확인할 수 없습니다.")
+            raise http_error(400, "sso.email_unavailable", lang)
         users = load_users()
         if email not in users:
             if invite_gate_enabled and not entry.invite_authorized:
-                raise HTTPException(
-                    status_code=403,
-                    detail="신규 SSO 계정에는 유효한 서명 초대 권한이 필요합니다.",
-                )
+                raise http_error(403, "sso.invitation_required", lang)
             is_first = len(users) == 0
             users[email] = {
                 "password": "",
@@ -280,7 +276,7 @@ def create_auth_router(
                 ensure_identity(email, users[email])
             save_users(users)
         if users[email].get("disabled"):
-            raise HTTPException(status_code=403, detail="비활성화된 계정입니다.")
+            raise http_error(403, "auth.account_disabled", lang)
         token = create_session(email)
         resp = RedirectResponse("/app", status_code=302)
         resp.set_cookie(
@@ -309,33 +305,35 @@ def create_auth_router(
 
     @router.post("/account/change-password")
     async def change_password(req: ChangePasswordRequest, request: Request):
+        lang = resolve_language(request)
         email = normalize_email(require_user(request))
         if not email:
-            raise HTTPException(status_code=401, detail="인증이 필요합니다.")
-        _enforce_password_policy(req.new_password)
+            raise http_error(401, "auth.login_required", lang)
+        _enforce_password_policy(req.new_password, lang)
         users = load_users()
         user = users.get(email)
         if not user:
-            raise HTTPException(status_code=404, detail="사용자를 찾을 수 없습니다.")
+            raise http_error(404, "auth.user_not_found", lang)
         if not verify_and_migrate(email, req.current_password, user.get("password", ""), users):
-            raise HTTPException(status_code=401, detail="현재 비밀번호가 틀렸습니다.")
+            raise http_error(401, "auth.current_password_wrong", lang)
         users[email]["password"] = hash_password(req.new_password)
         save_users(users)
         return {"status": "ok", "message": "비밀번호가 변경되었습니다."}
 
     @router.patch("/account/profile")
     async def update_profile(req: UpdateProfileRequest, request: Request):
+        lang = resolve_language(request)
         email = normalize_email(require_user(request))
         if not email:
-            raise HTTPException(status_code=401, detail="인증이 필요합니다.")
+            raise http_error(401, "auth.login_required", lang)
         if req.name is not None and not req.name.strip():
-            raise HTTPException(status_code=400, detail="이름을 입력해주세요.")
+            raise http_error(400, "auth.name_required", lang)
         if req.nickname is not None and not req.nickname.strip():
-            raise HTTPException(status_code=400, detail="닉네임을 입력해주세요.")
+            raise http_error(400, "auth.nickname_required", lang)
         users = load_users()
         user = users.get(email)
         if not user:
-            raise HTTPException(status_code=404, detail="사용자를 찾을 수 없습니다.")
+            raise http_error(404, "auth.user_not_found", lang)
         if req.name is not None:
             users[email]["name"] = req.name.strip()
         if req.nickname is not None:
@@ -345,15 +343,16 @@ def create_auth_router(
 
     @router.get("/account/profile")
     async def get_profile(request: Request):
+        lang = resolve_language(request)
         email = normalize_email(require_user(request))
         if not email:
             if require_auth:
-                raise HTTPException(status_code=401, detail="인증이 필요합니다.")
+                raise http_error(401, "auth.login_required", lang)
             return {"email": "", "name": "Local User", "nickname": "You", "role": "admin", "is_admin": True}
         users = load_users()
         user = users.get(email)
         if not user:
-            raise HTTPException(status_code=404, detail="사용자를 찾을 수 없습니다.")
+            raise http_error(404, "auth.user_not_found", lang)
         role = get_user_role(email, users)
         return {"email": email, "name": user.get("name", ""), "nickname": user.get("nickname", ""),
                 "role": role, "is_admin": role == "admin"}

package/latticeai/api/browser.py

@@ -29,6 +29,7 @@ from pydantic import BaseModel
 from lattice_brain.ingestion import IngestionItem, capture_quality_verdict
 from latticeai import __version__
 from latticeai.api.workspace_scope import resolve_workspace_scope
+from latticeai.core.messages import DEFAULT_LANGUAGE, http_error, resolve_language
 from latticeai.core.quiet import quiet
 
 MAX_TAB_BYTES = 4 * 1024 * 1024          # 4 MB per captured tab payload
@@ -395,9 +396,9 @@ def create_browser_router(
     router = APIRouter()
     _fetch = fetch_url or _default_fetch_url
 
-    def _require_pipeline():
+    def _require_pipeline(language: str = DEFAULT_LANGUAGE):
         if pipeline is None or not pipeline.available():
-            raise HTTPException(status_code=503, detail="Knowledge Graph ingestion is disabled.")
+            raise http_error(503, "capture.ingestion_disabled", language)
 
     def _write_workspace(request: Request, body_workspace: Optional[str], user: str) -> Optional[str]:
         return resolve_workspace_scope(
@@ -412,7 +413,7 @@ def create_browser_router(
     async def read_url(req: ReadUrlRequest, request: Request):
         """Fetch a public URL locally and ingest it as a web_url source."""
         user = require_user(request)
-        _require_pipeline()
+        _require_pipeline(resolve_language(request))
         workspace_id = _write_workspace(request, req.workspace_id, user)
         url = _validate_http_url(req.url)
         try:
@@ -443,7 +444,7 @@ def create_browser_router(
     async def ingest_current_tab(req: IngestTabRequest, request: Request):
         """Ingest a payload captured from the local browser extension."""
         user = require_user(request)
-        _require_pipeline()
+        _require_pipeline(resolve_language(request))
         workspace_id = _write_workspace(request, req.workspace_id, user)
         url = _validate_http_url(req.url)
         # Bound the entire capture, not merely each field independently. The
@@ -462,14 +463,14 @@ def create_browser_router(
             if value
         )
         if captured_bytes > max_tab_bytes:
-            raise HTTPException(status_code=413, detail="Captured payload is too large.")
+            raise http_error(413, "capture.payload_too_large", resolve_language(request))
         text = (req.text or "").strip()
         if not text and req.html:
             _title, text = extract_readable_text(req.html)
         if not text:
             text = (req.selected_text or "").strip()
         if not text:
-            raise HTTPException(status_code=400, detail="No text, html, or selected_text provided.")
+            raise http_error(400, "capture.nothing_to_capture", resolve_language(request))
         res = pipeline.ingest(
             IngestionItem(
                 source_type="browser_tab",

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.8.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.8.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent", "ingestion_bridge")