ltcai 8.7.0 → 8.9.0

package/lattice_brain/graph/json_utils.py

@@ -0,0 +1,25 @@
+"""JSON helpers shared by graph storage, projection, and retrieval modules."""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, Dict, Optional
+
+
+def _json(data: Optional[Dict[str, Any]]) -> str:
+    return json.dumps(data or {}, ensure_ascii=False, sort_keys=True)
+
+
+def _safe_loads(raw: Optional[str]) -> Dict[str, Any]:
+    """Tolerantly parse a metadata_json column — returns {} on corrupt rows."""
+    if not raw:
+        return {}
+    try:
+        value = json.loads(raw)
+        return value if isinstance(value, dict) else {}
+    except (json.JSONDecodeError, TypeError) as e:
+        logging.warning(
+            "knowledge_graph: corrupt metadata_json (%s) — using empty dict", e
+        )
+        return {}

package/lattice_brain/graph/retrieval.py

@@ -55,9 +55,18 @@ class KnowledgeGraphRetrievalMixin:
                 extracted = meta.get("extracted") or {}
                 node_id = row["id"]
                 chunk_count = conn.execute(
-                    f"SELECT COUNT(*) AS c FROM {nt} WHERE type='Chunk' AND metadata_json LIKE ?",
-                    (f"%{node_id}%",),
+                    "SELECT COUNT(*) AS c FROM chunks WHERE source_node=?",
+                    (node_id,),
                 ).fetchone()["c"]
+                if not chunk_count:
+                    # Legacy projections represented chunks as graph nodes and
+                    # linked them only through metadata_json. Keep read
+                    # compatibility without making the fragile LIKE path the
+                    # primary query.
+                    chunk_count = conn.execute(
+                        f"SELECT COUNT(*) AS c FROM {nt} WHERE type='Chunk' AND metadata_json LIKE ?",
+                        (f"%{node_id}%",),
+                    ).fetchone()["c"]
                 documents.append(
                     {
                         "id": node_id,
@@ -255,7 +264,7 @@ class KnowledgeGraphRetrievalMixin:
             node.pop("_raw_importance", None)
         return {"nodes": nodes, "edges": edges}
 
-    def search(self, query: str, limit: int = 30) -> Dict[str, Any]:
+    def search(self, query: str, limit: int = 30, *, allowed_workspaces=None) -> Dict[str, Any]:
         query = str(query or "").strip()
         q = f"%{query}%"
         limit = max(1, min(int(limit or 30), 100))
@@ -347,9 +356,7 @@ class KnowledgeGraphRetrievalMixin:
             # the legacy LIKE path regardless of FTS bm25 tie ordering.
             rows = sorted(rows, key=lambda r: r["id"])
             rows = sorted(rows, key=score, reverse=True)[:limit]
-        return {
-            "query": query,
-            "matches": [
+        matches = [
                 {
                     "id": row["id"],
                     "type": row["type"],
@@ -359,15 +366,17 @@ class KnowledgeGraphRetrievalMixin:
                     "updated_at": row["updated_at"],
                 }
                 for row in rows
-            ],
-        }
+            ]
+        if allowed_workspaces is not None:
+            matches = self.filter_scoped_nodes(matches, allowed_workspaces)
+        return {"query": query, "matches": matches}
 
-    def context_for_query(self, query: str, limit: int = 6) -> str:
+    def context_for_query(self, query: str, limit: int = 6, *, allowed_workspaces=None) -> str:
         """Return compact graph-backed RAG context for chat generation."""
         query = str(query or "").strip()
         if not query:
             return ""
-        matches = self.search(query, limit).get("matches", [])
+        matches = self.search(query, limit, allowed_workspaces=allowed_workspaces).get("matches", [])
         if not matches:
             topics = _topic_candidates(query, limit=4)
             if topics:
@@ -404,6 +413,8 @@ class KnowledgeGraphRetrievalMixin:
                     )
                     if len(matches) >= limit:
                         break
+                if allowed_workspaces is not None:
+                    matches = self.filter_scoped_nodes(matches, allowed_workspaces)
         lines = []
         for match in matches[:limit]:
             meta = match.get("metadata") or {}
@@ -420,8 +431,10 @@ class KnowledgeGraphRetrievalMixin:
             )
         return "\n".join(lines)
 
-    def neighbors(self, node_id: str) -> Dict[str, Any]:
+    def neighbors(self, node_id: str, *, allowed_workspaces=None) -> Dict[str, Any]:
         """Return direct neighbors (1-hop) of a node."""
+        if allowed_workspaces is not None and not self.filter_scoped_nodes([{"id": node_id}], allowed_workspaces):
+            raise ValueError(f"graph node not found: {node_id}")
         nt, et = self._read_tables()
         with self._connect() as conn:
             edge_rows = conn.execute(
@@ -458,9 +471,17 @@ class KnowledgeGraphRetrievalMixin:
                         list(neighbor_ids),
                     )
                 ]
+        if allowed_workspaces is not None:
+            nodes = self.filter_scoped_nodes(nodes, allowed_workspaces)
+            kept = {node.get("id") for node in nodes}
+            edges = [
+                edge for edge in edges
+                if (edge.get("from") == node_id or edge.get("from") in kept)
+                and (edge.get("to") == node_id or edge.get("to") in kept)
+            ]
         return {"node_id": node_id, "neighbors": nodes, "edges": edges}
 
-    def get_node(self, node_id: str) -> Dict[str, Any]:
+    def get_node(self, node_id: str, *, allowed_workspaces=None) -> Dict[str, Any]:
         node_id = str(node_id or "").strip()
         if not node_id:
             raise ValueError("node_id required")
@@ -480,7 +501,7 @@ class KnowledgeGraphRetrievalMixin:
                 f"SELECT COUNT(*) AS c FROM {et} WHERE from_node=? OR to_node=?",
                 (node_id, node_id),
             ).fetchone()["c"]
-        return {
+        node = {
             "id": row["id"],
             "type": row["type"],
             "title": row["title"],
@@ -489,6 +510,9 @@ class KnowledgeGraphRetrievalMixin:
             "updated_at": row["updated_at"],
             "degree": degree,
         }
+        if allowed_workspaces is not None and not self.filter_scoped_nodes([node], allowed_workspaces):
+            raise ValueError(f"graph node not found: {node_id}")
+        return node
 
     def relationship_search(
         self,
@@ -497,6 +521,7 @@ class KnowledgeGraphRetrievalMixin:
         node_id: str = "",
         relationship_type: str = "",
         limit: int = 30,
+        allowed_workspaces=None,
     ) -> Dict[str, Any]:
         query = str(query or "").strip()
         node_id = str(node_id or "").strip()
@@ -535,11 +560,7 @@ class KnowledgeGraphRetrievalMixin:
                     """,
                 (*params, limit),
             ).fetchall()
-        return {
-            "query": query,
-            "node_id": node_id,
-            "relationship_type": relationship_type,
-            "relationships": [
+        relationships = [
                 {
                     "id": row["id"],
                     "type": row["type"],
@@ -562,15 +583,32 @@ class KnowledgeGraphRetrievalMixin:
                     },
                 }
                 for row in rows
-            ],
+            ]
+        if allowed_workspaces is not None:
+            kept = []
+            for rel in relationships:
+                endpoints = [
+                    {"id": (rel.get("source") or {}).get("id")},
+                    {"id": (rel.get("target") or {}).get("id")},
+                ]
+                if len(self.filter_scoped_nodes(endpoints, allowed_workspaces)) == 2:
+                    kept.append(rel)
+            relationships = kept
+        return {
+            "query": query,
+            "node_id": node_id,
+            "relationship_type": relationship_type,
+            "relationships": relationships,
         }
 
     def traverse(
-        self, node_id: str, *, depth: int = 1, limit: int = 100
+        self, node_id: str, *, depth: int = 1, limit: int = 100, allowed_workspaces=None
     ) -> Dict[str, Any]:
         node_id = str(node_id or "").strip()
         if not node_id:
             raise ValueError("node_id required")
+        if allowed_workspaces is not None and not self.filter_scoped_nodes([{"id": node_id}], allowed_workspaces):
+            raise ValueError(f"graph node not found: {node_id}")
         depth = max(0, min(int(depth or 1), 4))
         limit = max(1, min(int(limit or 100), 500))
         nt, et = self._read_tables()
@@ -617,10 +655,7 @@ class KnowledgeGraphRetrievalMixin:
                     """,
                 list(visited),
             ).fetchall()
-        return {
-            "root": node_id,
-            "depth": depth,
-            "nodes": [
+        nodes = [
                 {
                     "id": row["id"],
                     "type": row["type"],
@@ -630,9 +665,13 @@ class KnowledgeGraphRetrievalMixin:
                     "updated_at": row["updated_at"],
                 }
                 for row in node_rows
-            ],
-            "edges": list(edges_by_id.values()),
-        }
+            ]
+        edges = list(edges_by_id.values())
+        if allowed_workspaces is not None:
+            nodes = self.filter_scoped_nodes(nodes, allowed_workspaces)
+            kept = {node.get("id") for node in nodes}
+            edges = [edge for edge in edges if edge.get("from") in kept and edge.get("to") in kept]
+        return {"root": node_id, "depth": depth, "nodes": nodes, "edges": edges}
 
     def _iter_vector_source_items(
         self,

package/lattice_brain/graph/runtime.py

@@ -0,0 +1,16 @@
+"""Runtime hooks for the knowledge graph package."""
+
+from __future__ import annotations
+
+from typing import Any
+
+_llm_router_ref: Any = None
+
+
+def set_llm_router(router_instance: Any) -> None:
+    global _llm_router_ref
+    _llm_router_ref = router_instance
+
+
+def get_llm_router() -> Any:
+    return _llm_router_ref

package/lattice_brain/ingestion.py

@@ -132,7 +132,7 @@ class IngestionPipeline:
     # ── public API ───────────────────────────────────────────────────────────
     def ingest(self, item: IngestionItem, *, user_email: Optional[str] = None) -> IngestionResult:
         """Normalize, hash, route through dispatch_tool, and record provenance."""
-        source_type = str(item.source_type or "text").strip()
+        source_type = str(item.source_type or "text").strip().lower()
         if not self.available():
             return IngestionResult(
                 status="unavailable", source_type=source_type,
@@ -187,25 +187,33 @@ class IngestionPipeline:
         embedded = bool(self._kg.node_is_embedded(node_id)) if node_id else False
         title = raw.get("title") or item.title
 
-        prov = self._kg.record_provenance(
-            node_id=node_id,
-            source_type=source_type,
-            pipeline=self._pipeline_name,
-            source_uri=item.source_uri,
-            content_hash=content_hash,
-            title=title,
-            owner=owner,
-            workspace_id=item.workspace_id,
-            captured_at=captured_at,
-            modified_at=item.modified_at,
-            embedded=embedded,
-            linked=bool(raw.get("source_node_id")),
-            duplicate=bool(raw.get("duplicate")),
-            agent_used=item.agent_used,
-            chunk_count=len(chunk_ids),
-            permissions=item.permissions,
-            metadata=item.metadata,
-        )
+        # Provenance capture must never turn an already-persisted ingest into a
+        # caller-visible failure: the graph write above succeeded, so a broken
+        # provenance table degrades the result instead of raising.
+        provenance_detail: Optional[str] = None
+        try:
+            prov = self._kg.record_provenance(
+                node_id=node_id,
+                source_type=source_type,
+                pipeline=self._pipeline_name,
+                source_uri=item.source_uri,
+                content_hash=content_hash,
+                title=title,
+                owner=owner,
+                workspace_id=item.workspace_id,
+                captured_at=captured_at,
+                modified_at=item.modified_at,
+                embedded=embedded,
+                linked=bool(raw.get("source_node_id")),
+                duplicate=bool(raw.get("duplicate")),
+                agent_used=item.agent_used,
+                chunk_count=len(chunk_ids),
+                permissions=item.permissions,
+                metadata=item.metadata,
+            )
+        except Exception as exc:  # noqa: BLE001 — the ingest itself already landed
+            prov = {}
+            provenance_detail = f"provenance capture failed: {exc}"
         if self._audit is not None:
             try:
                 self._audit(
@@ -232,11 +240,16 @@ class IngestionPipeline:
             embedded=embedded,
             indexing_status="indexed",
             provenance_id=prov.get("id"),
+            detail=provenance_detail,
         )
 
     # ── routing helpers ──────────────────────────────────────────────────────
     def _ingest_text(self, item, *, source_type, owner, captured_at) -> Dict[str, Any]:
         text = item.text or ""
+        if not text.strip():
+            raise ValueError(
+                f"Empty content: {source_type} ingestion requires non-empty text."
+            )
         if len(text.encode("utf-8", "ignore")) > self._max_text_bytes:
             raise ValueError(
                 f"Text payload exceeds the {self._max_text_bytes // (1024 * 1024)}MB ingestion limit."
@@ -297,6 +310,8 @@ class IngestionPipeline:
         path = Path(item.path)
         if not path.exists():
             raise FileNotFoundError(f"File not found: {path}")
+        if path.is_dir():
+            raise ValueError(f"File ingestion requires a file, got a directory: {path}")
         return self._kg.ingest_document(
             path,
             original_filename=item.title or path.name,

package/lattice_brain/runtime/agent_runtime.py

@@ -42,6 +42,7 @@ from .contracts import (
     contract_views,
     extract_contract,
     multi_agent_contract,
+    run_record_contract,
     runtime_boundary_contract,
 )
 
@@ -308,7 +309,7 @@ class AgentRuntime:
     def get_run(self, run_id: str, *, scope: Optional[str] = None) -> Dict[str, Any]:
         run = self._store.get_agent_run(run_id, workspace_id=scope)
         payload = {"run": run}
-        contract = extract_contract(run)
+        contract = self._ensure_contract(run)
         if contract is not None:
             payload["contract"] = contract_view(contract)
         return payload
@@ -324,7 +325,7 @@ class AgentRuntime:
     def events(self, run_id: str, *, scope: Optional[str] = None) -> Dict[str, Any]:
         run = self._store.get_agent_run(run_id, workspace_id=scope)
         status = str(run.get("status") or "")
-        contract = extract_contract(run)
+        contract = self._ensure_contract(run)
         return {
             "run_id": run_id,
             "status": status,
@@ -364,6 +365,35 @@ class AgentRuntime:
     def _clamp_retries(self, max_retries: int) -> int:
         return max(0, min(int(max_retries or 0), self._max_retries_cap))
 
+    def _validate_roles(self, roles: Optional[List[str]]) -> Optional[List[str]]:
+        """Reject unknown roles at the boundary instead of deep in orchestration.
+
+        ``preview`` reports unknown roles as a blocking reason; execution paths
+        must enforce the same contract so a run can never be recorded with a
+        role the runtime does not own.
+        """
+        if not roles:
+            return None
+        unknown = [role for role in roles if role not in AGENT_ROLES]
+        if unknown:
+            raise ValueError(f"unknown roles: {', '.join(unknown)}")
+        return list(roles)
+
+    @staticmethod
+    def _ensure_contract(record: Any) -> Optional[Dict[str, Any]]:
+        """Return the record's family contract, synthesizing one for legacy rows.
+
+        Every read surface (get_run/events/replay) must expose the
+        ``agent-run-contract/v1`` envelope even for runs persisted before the
+        contract family existed, so consumers never need a legacy branch.
+        """
+        contract = extract_contract(record)
+        if contract is not None:
+            return contract
+        if isinstance(record, dict) and record.get("id"):
+            return run_record_contract(record)
+        return None
+
     @staticmethod
     def _result_patch(result: Any, goal: str) -> Dict[str, Any]:
         return {
@@ -420,6 +450,7 @@ class AgentRuntime:
         """Create the durable queued row used by the async executor."""
         if not str(goal or "").strip():
             raise ValueError("goal is required")
+        roles = self._validate_roles(roles)
         pre_dispatch = self._fire_pre_run(
             goal=goal,
             roles=roles,
@@ -454,7 +485,9 @@ class AgentRuntime:
             execution_mode="async",
             requested_roles=roles or None,
             inputs=inputs or {},
-            max_retries=max_retries,
+            # Persist the clamped budget so the durable row reflects what the
+            # executor will actually honor, not the raw client request.
+            max_retries=self._clamp_retries(max_retries),
         )
         payload: Dict[str, Any] = {"run": run}
         if pre_dispatch is not None:
@@ -574,6 +607,7 @@ class AgentRuntime:
     ) -> Dict[str, Any]:
         if not str(goal or "").strip():
             raise ValueError("goal is required")
+        roles = self._validate_roles(roles)
 
         pre_dispatch = self._fire_pre_run(
             goal=goal,

package/lattice_brain/runtime/multi_agent.py

@@ -21,7 +21,7 @@ from typing import Any, Callable, Dict, List, Optional
 from .contracts import multi_agent_contract
 
 
-MULTI_AGENT_VERSION = "8.7.0"
+MULTI_AGENT_VERSION = "8.9.0"
 
 AGENT_ROLES = ("researcher", "planner", "executor", "reviewer", "release")
 CORE_PIPELINE = ("planner", "executor", "reviewer")

package/latticeai/__init__.py

@@ -1,3 +1,3 @@
 """Lattice AI - modular server package."""
 
-__version__ = "8.7.0"
+__version__ = "8.9.0"

package/latticeai/api/chat.py

@@ -286,6 +286,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
     group_history_conversations = context.group_history_conversations
     get_conversation_messages = context.get_conversation_messages
     conversation_title = context.conversation_title
+    allowed_workspaces_for = context.allowed_workspaces_for
 
     CONFIG = context.config
     CHAT_SERVICE = context.chat_service
@@ -314,6 +315,18 @@ def create_chat_router(context: AppContext) -> APIRouter:
         except Exception as exc:
             logging.warning("chat message bridge failed: %s", exc)
 
+    def history_scope_for_user(user_email: Optional[str]) -> Dict:
+        require_auth = bool(getattr(CONFIG, "require_auth", False))
+        scoped_user = user_email if require_auth else None
+        allowed = None
+        if require_auth and scoped_user and allowed_workspaces_for is not None:
+            allowed = allowed_workspaces_for(scoped_user)
+        return {
+            "user_email": scoped_user,
+            "allowed_workspaces": allowed,
+            "include_legacy_global": not require_auth,
+        }
+
     def recent_chat_context(
         limit: int = 10,
         include_image_missing_replies: bool = True,
@@ -449,14 +462,14 @@ def create_chat_router(context: AppContext) -> APIRouter:
                 except Exception as e:
                     logging.warning("knowledge graph clear event ingest failed: %s", e)
             if command == "/clear_all":
-                result = clear_history(0)
+                result = clear_history(0, **history_scope_for_user(effective_email))
                 answer = f"채팅창을 정리했습니다. 화면에서 제거 {result.get('removed', 0)}개. 감사 로그와 지식 그래프/RAG 데이터는 유지됩니다."
             else:
                 if req.conversation_id:
-                    result = clear_conversation(req.conversation_id)
+                    result = clear_conversation(req.conversation_id, **history_scope_for_user(effective_email))
                     answer = f"현재 대화방 채팅창을 정리했습니다. 화면에서 제거 {result.get('removed', 0)}개. 감사 로그와 지식 그래프/RAG 데이터는 유지됩니다."
                 else:
-                    result = clear_history(0)
+                    result = clear_history(0, **history_scope_for_user(effective_email))
                     answer = f"채팅창을 정리했습니다. 화면에서 제거 {result.get('removed', 0)}개. 감사 로그와 지식 그래프/RAG 데이터는 유지됩니다."
             append_audit_event(
                 "clear_command",
@@ -791,20 +804,20 @@ def create_chat_router(context: AppContext) -> APIRouter:
     @api_router.get("/history")
     async def fetch_history(request: Request):
         """웹 화면에서 이전 대화를 불러올 수 있도록 히스토리를 반환합니다."""
-        require_user(request)
-        return get_history()
+        current_user = require_user(request)
+        return get_history(**history_scope_for_user(current_user))
 
     @api_router.get("/history/conversations")
     async def fetch_history_conversations(request: Request):
         """저장된 히스토리를 대화 단위로 묶어 반환합니다."""
-        require_user(request)
-        return group_history_conversations()
+        current_user = require_user(request)
+        return group_history_conversations(get_history(**history_scope_for_user(current_user)))
 
     @api_router.get("/history/conversations/{conversation_id:path}")
     async def fetch_history_conversation(conversation_id: str, request: Request):
         """선택한 대화의 메시지를 반환합니다."""
-        require_user(request)
-        messages = get_conversation_messages(conversation_id)
+        current_user = require_user(request)
+        messages = get_conversation_messages(conversation_id, **history_scope_for_user(current_user))
         if not messages:
             raise HTTPException(status_code=404, detail="대화를 찾을 수 없습니다.")
         return {"id": conversation_id, "messages": messages}
@@ -814,7 +827,11 @@ def create_chat_router(context: AppContext) -> APIRouter:
     async def delete_history_conversation(conversation_id: str, request: Request):
         """선택한 대화방의 메시지만 삭제합니다."""
         email = require_user(request)
-        result = clear_conversation(conversation_id, request.query_params.get("started_at"))
+        result = clear_conversation(
+            conversation_id,
+            request.query_params.get("started_at"),
+            **history_scope_for_user(email),
+        )
         append_audit_event(
             "conversation_delete",
             user_email=email,
@@ -829,7 +846,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
     @api_router.delete("/history")
     async def delete_history(request: Request, keep_last: int = 0):
         email = require_user(request)
-        result = clear_history(keep_last)
+        result = clear_history(keep_last, **history_scope_for_user(email))
         append_audit_event(
             "history_delete",
             user_email=email,
@@ -842,11 +859,11 @@ def create_chat_router(context: AppContext) -> APIRouter:
     @api_router.get("/history/search")
     async def search_history(q: str, request: Request):
         """키워드로 채팅 히스토리를 검색합니다."""
-        require_user(request)
+        current_user = require_user(request)
         if not q or not q.strip():
             return {"results": [], "query": q}
         q_lower = q.strip().lower()
-        history = get_history()
+        history = get_history(**history_scope_for_user(current_user))
         matches = [item for item in history if q_lower in (item.get("content") or "").lower()]
         grouped: Dict[str, Dict] = {}
         for item in matches:
@@ -991,7 +1008,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
             }
 
         # Auto-approve and run to completion (default behaviour)
-        _AGENT_RUNTIME.approve(ctx, current_user)
+        _AGENT_RUNTIME.approve(ctx, current_user, approved_by_human=True)
         return await _agent_finish(ctx, req, lang_hint, current_user, max_steps, max_retry)
 
     

package/latticeai/api/mcp.py

@@ -30,6 +30,7 @@ from latticeai.core.mcp_registry import (
     SKILLS_DIR,
 )
 from latticeai.core.tool_registry import MCP_TOOL_DESCRIPTIONS
+from latticeai.services.tool_dispatch import enforce_tool_policy
 from tools import AGENT_ROOT, execute_tool
 
 
@@ -392,7 +393,7 @@ def create_mcp_router(
                     args.get("limit", 6),
                 )
             }
-        _check_tool_role(req.action, current_user)
-        return _tool_response(execute_tool, req.action, req.args or {})
+        enforce_tool_policy(req.action, req.args or {}, current_user=current_user, source="mcp")
+        return _tool_response(execute_tool, req.action, req.args or {}, source="mcp")
 
     return router

package/latticeai/api/models.py

@@ -67,6 +67,7 @@ class LoadModelRequest(BaseModel):
 
 class InstallEngineRequest(BaseModel):
     engine: str
+    confirmation_token: Optional[str] = None
 
 
 class SetApiKeyRequest(BaseModel):
@@ -99,7 +100,7 @@ def create_models_router(
     get_current_user: Callable[[Request], Optional[str]],
     load_users: Callable[[], Dict],
     get_user_role: Callable[..., str],
-    install_engine: Callable[[str], Dict],
+    install_engine: Callable[..., Dict],
     verify_cloud_models: Callable[..., Any],
     normalize_local_model_request: Callable[..., str],
     download_hf_model: Callable[..., Dict],
@@ -281,6 +282,8 @@ def create_models_router(
     @router.post("/engines/install")
     async def engines_install(req: InstallEngineRequest, request: Request):
         require_user(request)
+        if req.confirmation_token:
+            return install_engine(req.engine, confirmation_token=req.confirmation_token)
         return install_engine(req.engine)
 
     @router.post("/engines/verify-cloud")