ltcai 10.2.0 → 10.4.0

package/latticeai/cli/entrypoint.py

@@ -29,7 +29,7 @@ def _local_ips() -> list[str]:
     try:
         hostname = socket.gethostname()
         for info in socket.getaddrinfo(hostname, None):
-            addr = info[4][0]
+            addr = str(info[4][0])
             if ":" not in addr and not addr.startswith("127."):
                 if addr not in ips:
                     ips.append(addr)

package/latticeai/core/agent.py

@@ -24,7 +24,17 @@ import json
 import logging
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Awaitable, Callable, Dict, FrozenSet, List, Optional, Tuple
+from typing import (
+    Any,
+    Awaitable,
+    Callable,
+    Dict,
+    FrozenSet,
+    List,
+    Mapping,
+    Optional,
+    Tuple,
+)
 
 from lattice_brain.runtime.contracts import (
     runtime_boundary_contract,
@@ -149,10 +159,10 @@ class AgentDeps:
 
     # ── tool port ────────────────────────────────────────────────────
     execute_tool: Callable[[str, dict], dict]
-    policy_for: Callable[[str, dict], dict]        # name, args -> governance policy
-    risk_level: Callable[[dict], str]              # policy -> "low"|"medium"|"high"
+    policy_for: Callable[[str, dict], Mapping[str, Any]]   # name, args -> policy
+    risk_level: Callable[[Any], str]               # policy -> "low"|"medium"|"high"
     check_role: Callable[[str, str], None]         # tool_name, user -> raises if not allowed
-    tool_governance: Dict[str, dict]               # name -> policy (for auto_approve set)
+    tool_governance: Mapping[str, Mapping[str, Any]]  # name -> policy (auto_approve set)
     file_create_actions: FrozenSet[str]
 
     # ── context / memory / audit ports ───────────────────────────────
@@ -246,18 +256,22 @@ class SingleAgentRuntime:
         injected = getattr(self.deps, "phase_budgets", None)
         if injected is not None:
             return injected
-        if getattr(self, "_env_phase_budgets", None) is None:
-            self._env_phase_budgets = PhaseBudgets.from_env()
-        return self._env_phase_budgets
+        cached = getattr(self, "_env_phase_budgets", None)
+        if cached is None:
+            cached = PhaseBudgets.from_env()
+            self._env_phase_budgets = cached
+        return cached
 
     @property
     def transcript_budget(self) -> TranscriptBudget:
         injected = getattr(self.deps, "transcript_budget", None)
         if injected is not None:
             return injected
-        if getattr(self, "_env_transcript_budget", None) is None:
-            self._env_transcript_budget = TranscriptBudget.from_env()
-        return self._env_transcript_budget
+        cached = getattr(self, "_env_transcript_budget", None)
+        if cached is None:
+            cached = TranscriptBudget.from_env()
+            self._env_transcript_budget = cached
+        return cached
 
     # ── permission mode (v9.9.8) ─────────────────────────────────────
     def resolve_permission_mode(
@@ -511,7 +525,7 @@ class SingleAgentRuntime:
                     break
                 continue
 
-            name     = action.get("action")
+            name     = str(action.get("action") or "")
             thoughts = str(action.get("thoughts") or "")[:600]
             args     = action.get("args") or {}
 
@@ -748,7 +762,7 @@ class SingleAgentRuntime:
 
     def _governor_review(
         self, ctx: AgentRunContext, name: str, thoughts: str, args: dict,
-        policy: dict, risk: str, current_user: str, request_workspace: Optional[str],
+        policy: Mapping[str, Any], risk: str, current_user: str, request_workspace: Optional[str],
         conversation_id: Optional[str] = None,
     ) -> Tuple[bool, bool]:
         """Central change-class governance: create-new runs with minimal
@@ -817,7 +831,7 @@ class SingleAgentRuntime:
 
     def _blocked_by_gates(
         self, ctx: AgentRunContext, req: Any, name: str, thoughts: str, args: dict,
-        policy: dict, risk: str, current_user: str, governor_allows_additive: bool,
+        policy: Mapping[str, Any], risk: str, current_user: str, governor_allows_additive: bool,
     ) -> bool:
         """Destructive / circuit-breaker / explicit-approval gates.
 
@@ -892,7 +906,7 @@ class SingleAgentRuntime:
 
     def _dispatch_step(
         self, ctx: AgentRunContext, name: str, thoughts: str, args: dict,
-        policy: dict, risk: str, current_user: str,
+        policy: Mapping[str, Any], risk: str, current_user: str,
     ) -> None:
         """Role check + shared tool lifecycle, recorded on the transcript either way."""
         d = self.deps

package/latticeai/core/audit.py

@@ -87,7 +87,7 @@ def mask_sensitive_text(text: str, matches: List[Dict]) -> str:
 
 def classify_sensitive_message(item: Dict, index: int) -> Dict:
     content = str(item.get("content", ""))
-    found = []
+    found: List[Dict[str, Any]] = []
     seen: set = set()
     for rule in SENSITIVE_PATTERNS:
         for match in re.finditer(rule["pattern"], content, flags=re.IGNORECASE):
@@ -104,9 +104,11 @@ def classify_sensitive_message(item: Dict, index: int) -> Dict:
             })
     severity = "none"
     if found:
-        severity = max(found, key=lambda m: SEVERITY_SCORE[m["severity"]])["severity"]
+        severity = str(
+            max(found, key=lambda m: SEVERITY_SCORE[str(m["severity"])])["severity"]
+        )
     preview_text = content[:240]
-    preview_matches = [m for m in found if m["start"] < len(preview_text)]
+    preview_matches = [m for m in found if int(m["start"]) < len(preview_text)]
     return {
         "index": index,
         "role": item.get("role", ""),

package/latticeai/core/embedding_providers.py

@@ -34,7 +34,7 @@ import math
 import os
 import struct
 from dataclasses import dataclass, field
-from typing import Any, Dict, Iterable, List, Optional, Sequence
+from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple
 
 from latticeai.core.local_embeddings import DEFAULT_EMBEDDING_DIM, LocalEmbeddingModel
 
@@ -288,6 +288,17 @@ class HashEmbeddingProvider(EmbeddingProvider):
         return {"status": "ok", "detail": "deterministic local fallback"}
 
 
+def _as_float_list(value: Any) -> List[Any]:
+    """A pooled embedding row as a flat list.
+
+    ``mx.array.tolist()`` is typed as scalar-or-nested; at this call site the
+    array is always 1-D, so a scalar would be a bug worth surfacing.
+    """
+    if isinstance(value, (int, float)):
+        raise EmbeddingUnavailable("MLX embedding produced a scalar, not a vector")
+    return list(value)
+
+
 # ── shared base for remote/model-backed providers ─────────────────────────────
 @dataclass
 class _RemoteConfig:
@@ -332,7 +343,7 @@ class MLXEmbeddingProvider(_NetworkEmbeddingProvider):
     def __init__(self, cfg: _RemoteConfig):
         super().__init__(cfg)
         self.model_id = f"mlx:{cfg.model}:{self.dim}"
-        self._encoder = None
+        self._encoder: Optional[Tuple[str, Any, Any]] = None
 
     def _load(self):
         if self._encoder is not None:
@@ -358,7 +369,7 @@ class MLXEmbeddingProvider(_NetworkEmbeddingProvider):
                 result = model(tokens)
                 pooled = result[0] if isinstance(result, (tuple, list)) else result
                 vec = mx.mean(pooled, axis=1)[0] if pooled.ndim == 3 else pooled[0]
-                out.append([float(x) for x in vec.tolist()])
+                out.append([float(x) for x in _as_float_list(vec.tolist())])
             return out
         except EmbeddingUnavailable:
             raise
@@ -477,7 +488,7 @@ class CustomEmbeddingProvider(_NetworkEmbeddingProvider):
         super().__init__(cfg)
         self._target_ref = str(cfg.extra.get("target") or os.getenv("LATTICEAI_EMBEDDING_CUSTOM_TARGET", ""))
         self.model_id = f"custom:{cfg.model or self._target_ref or 'callable'}:{self.dim}"
-        self._fn = None
+        self._fn: Optional[Callable[..., Any]] = None
 
     def _load(self):
         if self._fn is not None:
@@ -587,8 +598,10 @@ def resolve_embedder(
     """
     requested = str(provider or "hash").strip().lower() or "hash"
     if requested in {"hash", "local", "fallback", ""}:
-        prov = HashEmbeddingProvider(dim=int(dim or DEFAULT_EMBEDDING_DIM))
-        return ResolvedEmbedder(prov, "hash", "hash", False, prov.health(), "deterministic local fallback")
+        hash_prov = HashEmbeddingProvider(dim=int(dim or DEFAULT_EMBEDDING_DIM))
+        return ResolvedEmbedder(
+            hash_prov, "hash", "hash", False, hash_prov.health(), "deterministic local fallback"
+        )
 
     try:
         prov = build_embedding_provider(

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.2.0"
+LEGACY_COMPATIBILITY_VERSION = "10.4.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.2.0"
+MARKETPLACE_VERSION = "10.4.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent", "ingestion_bridge")
 
 
@@ -242,7 +242,7 @@ class TemplateCatalog:
         if not isinstance(payload, dict):
             raise MarketplaceError("template import payload must be an object")
         template = deepcopy(payload.get("template") or payload)
-        kind = _normalize_kind(template.get("kind") or payload.get("kind"))
+        kind = _normalize_kind(str(template.get("kind") or payload.get("kind") or ""))
         if not template.get("id"):
             raise MarketplaceError("template missing id")
         if not template.get("name"):

package/latticeai/core/mcp_catalog.py

@@ -7,7 +7,9 @@ MCP_REGISTRY`` sites are unaffected.
 
 from __future__ import annotations
 
-MCP_REGISTRY = [
+from typing import Any, Dict, List
+
+MCP_REGISTRY: List[Dict[str, Any]] = [
     {
         "id": "presentations",
         "name": "Presentations MCP",

package/latticeai/core/model_compat.py

@@ -431,7 +431,7 @@ def fast_postprocess(text: str, profile: Dict[str, Any]) -> str:
 SMOKE_PROMPT = "한국어로 한 문장만 답해. 2+2는?"
 
 
-def classify_smoke_response(text: str) -> Tuple[str, str]:
+def classify_smoke_response(text: Optional[str]) -> Tuple[str, str]:
     """Smoke test 응답을 ok / degraded / failed 로 분류한다. (item 3-3)
 
     - failed: 채팅에 쓸 수 없는 수준 (빈 응답, 특수/role 토큰 누출, 심한 반복,

package/latticeai/core/plugins.py

@@ -123,7 +123,7 @@ class PluginManifest:
         }
 
 
-def validate_manifest(data: Dict[str, Any], *, path: str = "") -> Tuple[Optional[PluginManifest], List[str]]:
+def validate_manifest(data: Any, *, path: str = "") -> Tuple[Optional[PluginManifest], List[str]]:
     """Validate a manifest dict. Returns ``(manifest_or_None, errors)``.
 
     A manifest with errors still returns ``None`` so callers never accidentally

package/latticeai/core/project_sessions.py

@@ -144,7 +144,7 @@ class ProjectSessionStore:
         workspace_id: Optional[str] = None,
     ) -> Dict[str, Any]:
         session_id = secrets.token_urlsafe(12)
-        record = {
+        record: Dict[str, Any] = {
             "id": session_id,
             "title": _clean(title, 200) or "프로젝트",
             "goal": _clean(goal, 2000),

package/latticeai/core/run_explain.py

@@ -84,8 +84,10 @@ def _repaired_artifacts(steps: Sequence[Mapping[str, Any]]) -> List[str]:
         meta = step.get("content_sanitize")
         if not isinstance(meta, Mapping) or not meta.get("repaired"):
             continue
-        result = step.get("result") if isinstance(step.get("result"), Mapping) else {}
-        args = step.get("args") if isinstance(step.get("args"), Mapping) else {}
+        raw_result = step.get("result")
+        raw_args = step.get("args")
+        result: Mapping[str, Any] = raw_result if isinstance(raw_result, Mapping) else {}
+        args: Mapping[str, Any] = raw_args if isinstance(raw_args, Mapping) else {}
         path = result.get("path") or args.get("path")
         if path and str(path) not in paths:
             paths.append(str(path))
@@ -270,7 +272,7 @@ def explain_run(
     repair_sum = sum(repair_totals.values())
 
     strain_score = parse_errors * 2 + corrections + retries + repair_totals["format"]
-    strain = {
+    strain: Dict[str, Any] = {
         "level": _strain_level(strain_score),
         "score": strain_score,
         "parse_errors": parse_errors,
@@ -336,7 +338,7 @@ def explain_run(
             "만들어지지 않은 파일: " + ", ".join(missing_files[:4]),
             "Files that were never written: " + ", ".join(missing_files[:4]),
         ))
-    strain_phrase = _STRAIN_PHRASES.get(strain["level"])
+    strain_phrase = _STRAIN_PHRASES.get(str(strain["level"]))
     if strain_phrase is not None:
         details.append(dict(strain_phrase))
 

package/latticeai/core/workspace_os.py

@@ -515,10 +515,6 @@ class WorkspaceOSStore:
         self.save_state(state)
         self.record_timeline_event("workspace", "member_removed", {"workspace_id": workspace_id, "user_id": user_id})
         return self._workspace_public(ws, actor)
-        ws["updated_at"] = _now()
-        self.save_state(state)
-        self.record_timeline_event("workspace", "member_removed", {"workspace_id": workspace_id, "user_id": user_id})
-        return self._workspace_public(ws, actor)
 
     def set_active_workspace(self, workspace_id: str, user_id: Optional[str] = None) -> Dict[str, Any]:
         state = self.load_state()

package/latticeai/core/workspace_os_constants.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 from typing import Dict
 
-WORKSPACE_OS_VERSION = "10.2.0"
+WORKSPACE_OS_VERSION = "10.4.0"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type

package/latticeai/core/workspace_os_state.py

@@ -71,7 +71,7 @@ def migrate_workspaces(state: Dict[str, Any]) -> Dict[str, Any]:
     for ws_id, ws in workspaces.items():
         if not isinstance(ws, dict):
             continue
-        ws_type = ws.get("type") if ws.get("type") in WORKSPACE_TYPES else "organization"
+        ws_type = str(ws.get("type")) if ws.get("type") in WORKSPACE_TYPES else "organization"
         if ws_id == DEFAULT_WORKSPACE_ID:
             ws_type = "personal"
         base = new_workspace_record(

package/latticeai/core/workspace_snapshots.py

@@ -31,9 +31,9 @@ class WorkspaceSnapshots:
         workspace_id: Optional[str] = None,
     ) -> Dict[str, Any]:
         scope = self._store._resolve_scope(workspace_id)
-        graph_payload = {"nodes": [], "edges": []}
-        graph_stats = {}
-        local_sources = {"sources": []}
+        graph_payload: Dict[str, Any] = {"nodes": [], "edges": []}
+        graph_stats: Dict[str, Any] = {}
+        local_sources: Dict[str, Any] = {"sources": []}
         if graph is not None:
             graph_payload = graph.graph(limit=2000)
             graph_stats = graph.stats()

package/latticeai/integrations/telegram_bot.py

@@ -7,6 +7,7 @@ import socket
 import tempfile
 import zipfile
 from pathlib import Path
+from typing import Any, Dict
 
 import httpx
 
@@ -678,6 +679,50 @@ def collect_generated_files(agent_data):
             files.append((path, target))
     return files
 
+def format_artifact_card(data, *, language: str = "ko") -> str:
+    """Artifact card summary for a finished run (v10.4.0).
+
+    Telegram used to send the produced files and nothing else, so a
+    deterministically repaired scaffold arrived looking exactly like clean
+    model output — SURFACE_PARITY recorded that as ◐. This renders the same
+    ``artifacts[]`` flags the web cards show, and reports only what the server
+    said: an absent flag is never promoted into a claim of validity.
+    """
+    if not isinstance(data, dict):
+        return ""
+    artifacts = data.get("artifacts")
+    if not isinstance(artifacts, list) or not artifacts:
+        return ""
+    korean = not str(language or "ko").startswith("en")
+    lines = ["📄 만든 파일" if korean else "📄 Files produced"]
+    for item in artifacts[:8]:
+        if not isinstance(item, dict):
+            continue
+        path = str(item.get("path") or "").strip()
+        if not path:
+            continue
+        notes = []
+        size = item.get("bytes")
+        if isinstance(size, (int, float)) and size > 0:
+            notes.append(f"{int(size):,} B")
+        if item.get("repaired") is True:
+            notes.append("자동 보정됨" if korean else "auto-repaired")
+        if item.get("valid") is False:
+            notes.append("검증 실패" if korean else "failed validation")
+        suffix = f" ({' · '.join(notes)})" if notes else ""
+        lines.append(f"• {path}{suffix}")
+    extra = len(artifacts) - 8
+    if extra > 0:
+        lines.append(f"… +{extra}")
+    return "\n".join(lines) if len(lines) > 1 else ""
+
+
+async def send_artifact_card(client, chat_id, data, *, language: str = "ko") -> None:
+    text = format_artifact_card(data, language=language)
+    if text:
+        await send_message(client, chat_id, text)
+
+
 def format_grounding_badge(data, *, language: str = "ko") -> str:
     """Answer-grounding badge line for a `/chat` reply (v9.9.7).
 
@@ -732,8 +777,10 @@ def format_proposals(payload) -> list:
         item_id = str(raw.get("id") or "").strip()
         if not item_id:
             continue
-        body = raw.get("payload") if isinstance(raw.get("payload"), dict) else {}
-        provenance = raw.get("provenance") if isinstance(raw.get("provenance"), dict) else {}
+        raw_body = raw.get("payload")
+        raw_prov = raw.get("provenance")
+        body: Dict[str, Any] = raw_body if isinstance(raw_body, dict) else {}
+        provenance: Dict[str, Any] = raw_prov if isinstance(raw_prov, dict) else {}
         path = str(body.get("path") or provenance.get("path") or "")
         title = str(raw.get("title") or path or item_id)
         change_class = str(body.get("change_class") or provenance.get("change_class") or "")
@@ -969,7 +1016,7 @@ async def handle_plan_callback(client, chat_id, data: str) -> None:
     # A callback is bound to the chat that received the plan. Even two allowed
     # chats cannot approve or cancel each other's plan by replaying callback
     # data.
-    if pending and int(pending.get("chat_id")) != int(chat_id):
+    if pending and int(pending.get("chat_id") or 0) != int(chat_id):
         await send_message(client, chat_id, "❌ 다른 채팅의 작업은 처리할 수 없습니다.")
         return
     pending = _bot_pending_plans.pop(pause_id, None)
@@ -1003,6 +1050,7 @@ async def handle_plan_callback(client, chat_id, data: str) -> None:
         await send_message(client, chat_id, str(ans))
         if isinstance(data_r, dict):
             await send_run_explanation(client, chat_id, data_r)
+            await send_artifact_card(client, chat_id, data_r)
             await send_generated_files(client, chat_id, collect_generated_files(data_r))
             await send_preview_links(client, chat_id, collect_preview_urls(data_r))
     except Exception as e:
@@ -1052,6 +1100,7 @@ async def process_ai_request(client, chat_id, user_text, image_data=None):
             await send_grounding_badge(client, chat_id, data)
         if not image_data and isinstance(data, dict):
             await send_run_explanation(client, chat_id, data)
+            await send_artifact_card(client, chat_id, data)
             await send_generated_files(client, chat_id, collect_generated_files(data))
             await send_preview_links(client, chat_id, collect_preview_urls(data))
     except Exception as e: