ltcai 10.0.0 → 10.2.0

package/latticeai/api/network_boundary.py

@@ -0,0 +1,220 @@
+"""Network boundary API — local_only / cloud_allowed dial + Phase 3 policy/UI."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional
+
+from fastapi import APIRouter, HTTPException, Request
+from pydantic import BaseModel, Field
+
+from latticeai.core.network_boundary import network_mode_catalog, normalize_network_mode
+from latticeai.services.cloud_egress_audit import record_cloud_egress
+from latticeai.services.cloud_token_guard import budget_for
+from latticeai.services.hybrid_context import build_minimal_context
+from latticeai.services.hybrid_policy import HybridPolicyService
+from latticeai.services.network_boundary_service import NetworkBoundaryService
+
+
+class SetNetworkBoundaryRequest(BaseModel):
+    mode: str = Field(..., description="local_only | cloud_allowed")
+    workspace_id: Optional[str] = None
+    acknowledge_risk: bool = False
+
+
+class PreviewRequest(BaseModel):
+    message: str
+    workspace_id: Optional[str] = None
+    top_k: int = 6
+
+
+class SetNodeSensitivityRequest(BaseModel):
+    node_id: str
+    local_only: bool = True
+    reason: Optional[str] = None
+    workspace_id: Optional[str] = None
+
+
+class SetHybridPolicyRequest(BaseModel):
+    workspace_id: Optional[str] = None
+    blocked_node_types: Optional[list[str]] = None
+    blocked_metadata_flags: Optional[list[str]] = None
+    auto_commit: Optional[bool] = None
+    allow_multimodal: Optional[bool] = None
+    min_extraction_confidence: Optional[float] = None
+
+
+def create_network_boundary_router(
+    *,
+    service: NetworkBoundaryService,
+    require_user: Callable[..., str],
+    knowledge_graph: Any = None,
+    policy_service: Optional[HybridPolicyService] = None,
+) -> APIRouter:
+    router = APIRouter(tags=["network-boundary"])
+
+    def _scope(request: Request, workspace_id: Optional[str] = None) -> tuple[str, Optional[str]]:
+        user = require_user(request)
+        header_ws = request.headers.get("X-Workspace-Id")
+        scope = workspace_id or (header_ws.strip() if header_ws else None)
+        return user, scope
+
+    @router.get("/api/network-boundary")
+    async def get_network_boundary(
+        request: Request,
+        workspace_id: Optional[str] = None,
+    ):
+        user, scope = _scope(request, workspace_id)
+        payload = service.get(user_email=user, workspace_id=scope)
+        scope_key = f"{user or 'anon'}|{scope or 'global'}"
+        payload["token_budget"] = budget_for(scope_key).snapshot()
+        if policy_service is not None:
+            payload["policy"] = policy_service.resolve(
+                user_email=user, workspace_id=scope
+            )
+        return payload
+
+    @router.get("/api/network-boundary/catalog")
+    async def network_boundary_catalog(request: Request):
+        require_user(request)
+        return {"modes": network_mode_catalog()}
+
+    @router.get("/api/network-boundary/ui-state")
+    async def network_boundary_ui_state(
+        request: Request,
+        workspace_id: Optional[str] = None,
+    ):
+        """Compact payload for the progressive-enhancement toggle panel."""
+        user, scope = _scope(request, workspace_id)
+        mode_payload = service.get(user_email=user, workspace_id=scope)
+        policy = (
+            policy_service.resolve(user_email=user, workspace_id=scope)
+            if policy_service is not None
+            else {}
+        )
+        scope_key = f"{user or 'anon'}|{scope or 'global'}"
+        return {
+            "mode": mode_payload.get("mode"),
+            "label": mode_payload.get("label"),
+            "label_ko": mode_payload.get("label_ko"),
+            "allows_cloud": mode_payload.get("allows_cloud"),
+            "requires_ack": mode_payload.get("requires_ack"),
+            "warning_ko": next(
+                (
+                    m.get("warning_ko")
+                    for m in (mode_payload.get("catalog") or [])
+                    if m.get("id") == mode_payload.get("mode")
+                ),
+                None,
+            ),
+            "policy": policy,
+            "token_budget": budget_for(scope_key).snapshot(),
+            "catalog": network_mode_catalog(),
+        }
+
+    @router.post("/api/network-boundary")
+    async def set_network_boundary(body: SetNetworkBoundaryRequest, request: Request):
+        user, scope = _scope(request, body.workspace_id)
+        try:
+            return service.set_mode(
+                normalize_network_mode(body.mode),
+                user_email=user,
+                workspace_id=scope,
+                acknowledge_risk=body.acknowledge_risk,
+                source="api",
+            )
+        except PermissionError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    @router.post("/api/network-boundary/preview")
+    async def preview_cloud_context(body: PreviewRequest, request: Request):
+        user, scope = _scope(request, body.workspace_id)
+        mode = service.resolve(user_email=user, workspace_id=scope)
+        minimal = build_minimal_context(
+            body.message,
+            store=knowledge_graph,
+            mode=mode,
+            top_k=max(1, min(int(body.top_k or 6), 12)),
+            allowed_workspaces={scope} if scope else None,
+        )
+        scope_key = f"{user or 'anon'}|{scope or 'global'}"
+        budget = budget_for(scope_key)
+        refusal = budget.check_turn(minimal.token_estimate)
+        return {
+            "mode": mode.value,
+            "allows_cloud": mode.value == "cloud_allowed",
+            "node_ids": minimal.node_ids,
+            "keywords": minimal.keywords,
+            "titles": [str(n.get("title") or n.get("id") or "") for n in minimal.nodes],
+            "types": [str(n.get("type") or "") for n in minimal.nodes],
+            "token_estimate": minimal.token_estimate,
+            "quality": minimal.quality,
+            "compact_preview": minimal.compact_text[:1200],
+            "token_budget": budget.snapshot(),
+            "would_block": refusal,
+        }
+
+    @router.post("/api/network-boundary/node-sensitivity")
+    async def set_node_sensitivity(body: SetNodeSensitivityRequest, request: Request):
+        """Mark one memory as never-leaving (or clear the mark).
+
+        The cloud filter has always looked for this flag. Until 10.2.0 nothing
+        in the product could set it, so the guard could not fire. Ingestion
+        stamps secret-bearing paths automatically; this covers what a path
+        cannot tell you — a note whose *content* is private.
+        """
+        user, scope = _scope(request, body.workspace_id)
+        if knowledge_graph is None or not hasattr(knowledge_graph, "set_node_sensitivity"):
+            raise HTTPException(status_code=501, detail="knowledge graph not available")
+        result = knowledge_graph.set_node_sensitivity(
+            body.node_id, local_only=bool(body.local_only), reason=body.reason
+        )
+        if not result.get("ok"):
+            raise HTTPException(status_code=404, detail=result.get("reason") or "node not found")
+        record_cloud_egress(
+            node_ids=[body.node_id], token_estimate=0, mode="(policy)",
+            provider="(local)", user_email=user, workspace_id=scope,
+            outcome="marked_local_only" if body.local_only else "cleared_local_only",
+            detail=body.reason,
+        )
+        return result
+
+    @router.get("/api/network-boundary/policy")
+    async def get_hybrid_policy(
+        request: Request,
+        workspace_id: Optional[str] = None,
+    ):
+        if policy_service is None:
+            raise HTTPException(status_code=501, detail="hybrid policy service not configured")
+        user, scope = _scope(request, workspace_id)
+        return policy_service.resolve(user_email=user, workspace_id=scope)
+
+    @router.post("/api/network-boundary/policy")
+    async def set_hybrid_policy(body: SetHybridPolicyRequest, request: Request):
+        if policy_service is None:
+            raise HTTPException(status_code=501, detail="hybrid policy service not configured")
+        user, scope = _scope(request, body.workspace_id)
+        patch: Dict[str, Any] = {}
+        for key in (
+            "blocked_node_types",
+            "blocked_metadata_flags",
+            "auto_commit",
+            "allow_multimodal",
+            "min_extraction_confidence",
+        ):
+            val = getattr(body, key, None)
+            if val is not None:
+                patch[key] = val
+        return policy_service.set_policy(
+            patch, user_email=user, workspace_id=scope, source="api"
+        )
+
+    return router
+
+
+__all__ = [
+    "create_network_boundary_router",
+    "SetNetworkBoundaryRequest",
+    "PreviewRequest",
+    "SetHybridPolicyRequest",
+    "SetNodeSensitivityRequest",
+]

package/latticeai/api/permissions.py

@@ -17,7 +17,6 @@ from fastapi import APIRouter, HTTPException, Request
 
 from latticeai.core.io_utils import atomic_write_json
 
-
 _PERMISSION_ACTION_LABELS = {
     "list": "폴더 목록 보기",
     "read": "파일 읽기",

package/latticeai/api/realtime.py

@@ -16,8 +16,8 @@ from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
-from latticeai.api.ui_redirects import app_redirect
 from lattice_brain.runtime.contracts import contract_views
+from latticeai.api.ui_redirects import app_redirect
 
 
 class PresenceRequest(BaseModel):

package/latticeai/api/security_dashboard.py

@@ -195,7 +195,7 @@ def _pdf_report(title: str, rows: List[Dict[str, Any]], overview: Dict[str, Any]
     try:
         from reportlab.lib.pagesizes import A4
         from reportlab.lib.styles import getSampleStyleSheet
-        from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table
+        from reportlab.platypus import Paragraph, SimpleDocTemplate, Spacer, Table
     except Exception:  # pragma: no cover
         return ("PDF library not available\n" + json.dumps(overview, ensure_ascii=False, indent=2)).encode("utf-8")
 

package/latticeai/api/setup.py

@@ -8,15 +8,24 @@ from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
+from lattice_brain.ingestion import IngestionItem
+from latticeai.models.router import parse_model_ref
 from latticeai.services.process_audit import command_plan
 from latticeai.setup.auto_setup import (
     plan as auto_setup_plan,
+)
+from latticeai.setup.auto_setup import (
     preset as auto_setup_preset,
+)
+from latticeai.setup.auto_setup import (
     probe as auto_setup_probe,
+)
+from latticeai.setup.auto_setup import (
     recommend as auto_setup_recommend,
+)
+from latticeai.setup.auto_setup import (
     verify as auto_setup_verify,
 )
-from latticeai.models.router import parse_model_ref
 from latticeai.setup.demo_corpus import (
     DEMO_DOCUMENTS,
     DEMO_METADATA_FLAG,
@@ -24,8 +33,12 @@ from latticeai.setup.demo_corpus import (
     demo_source_uri,
     suggested_questions,
 )
-from latticeai.setup.wizard import get_recommendations, install_stream, open_url, scan_environment
-from lattice_brain.ingestion import IngestionItem
+from latticeai.setup.wizard import (
+    get_recommendations,
+    install_stream,
+    open_url,
+    scan_environment,
+)
 
 
 class SetupInstallRequest(BaseModel):

package/latticeai/api/static_routes.py

@@ -15,6 +15,7 @@ from fastapi import APIRouter, Cookie, HTTPException, Request
 from fastapi.responses import FileResponse, HTMLResponse
 
 from latticeai.api.ui_redirects import app_redirect
+from latticeai.core.quiet import quiet
 
 PRODUCTION_CSP = (
     "default-src 'self'; "
@@ -282,7 +283,7 @@ def create_static_routes_router(
                 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:
-                pass
+                quiet()
         except Exception as e:
             result["error"] = str(e)
         return result

package/latticeai/api/tools.py

@@ -14,23 +14,27 @@ from fastapi import APIRouter, File, HTTPException, Request, UploadFile
 from fastapi.responses import FileResponse, Response
 from pydantic import BaseModel
 
+from lattice_brain.runtime.hooks import dispatch_tool
 from latticeai.api.computer_use import create_computer_use_router
 from latticeai.api.local_files import create_local_files_router
-from lattice_brain.runtime.hooks import dispatch_tool
 from latticeai.api.mcp import create_mcp_router
 from latticeai.api.permissions import create_permissions_router
-from latticeai.services.upload_service import process_uploaded_document
+from latticeai.services.router_context import ToolRouterContext
 from latticeai.services.tool_dispatch import (
     TOOL_GOVERNANCE,
-    TOOL_GOVERNANCE_DEFAULT as _TOOL_GOVERNANCE_DEFAULT,
-    check_tool_role as _check_tool_role,
-    get_tool_permission,
     enforce_tool_policy,
+    get_tool_permission,
     list_tool_permissions,
     tool_registry_diagnostics,
     tool_registry_manifest,
 )
-from latticeai.services.router_context import ToolRouterContext
+from latticeai.services.tool_dispatch import (
+    TOOL_GOVERNANCE_DEFAULT as _TOOL_GOVERNANCE_DEFAULT,
+)
+from latticeai.services.tool_dispatch import (
+    check_tool_role as _check_tool_role,
+)
+from latticeai.services.upload_service import process_uploaded_document
 from latticeai.tools import (
     AGENT_ROOT,
     ToolError,
@@ -39,7 +43,6 @@ from latticeai.tools import (
     create_pdf,
     create_pptx,
     create_xlsx,
-    read_document,
     deploy_project,
     edit_file,
     git_diff,
@@ -49,8 +52,8 @@ from latticeai.tools import (
     grep,
     inspect_html,
     knowledge_save,
-    knowledge_search,
     knowledge_scope_root,
+    knowledge_search,
     knowledge_tree,
     list_dir,
     network_status,
@@ -58,6 +61,7 @@ from latticeai.tools import (
     obsidian_search,
     obsidian_tree,
     preview_url,
+    read_document,
     read_file,
     run_command,
     search_files,

package/latticeai/api/voice_capture.py

@@ -19,6 +19,8 @@ from typing import Any, Callable, Optional
 
 from fastapi import APIRouter, File, Form, HTTPException, Request, UploadFile
 
+from latticeai.core.quiet import quiet
+
 LOGGER = logging.getLogger(__name__)
 
 
@@ -70,7 +72,7 @@ def create_voice_capture_router(
                 try:
                     tmp_path.unlink(missing_ok=True)
                 except OSError:
-                    pass
+                    quiet()
         if append_audit_event is not None:
             try:
                 append_audit_event(

package/latticeai/api/workflow_designer.py

@@ -75,10 +75,10 @@ def create_workflow_designer_router(
     from lattice_brain.workflow import (
         WorkflowEngine,
         WorkflowError,
-        validate_definition,
         export_workflow,
         import_workflow,
         legacy_steps_from_nodes,
+        validate_definition,
     )
 
     router = APIRouter()

package/latticeai/api/workspace.py

@@ -23,7 +23,6 @@ from pydantic import BaseModel
 from latticeai.api.ui_redirects import app_redirect
 from latticeai.services.app_context import AppContext
 
-
 # ── Request models (workspace-only; moved verbatim from server_app) ──────────
 
 class WorkspaceOnboardingStepRequest(BaseModel):
@@ -290,8 +289,8 @@ def create_workspace_router(context: AppContext) -> APIRouter:
         # not_recommended) for this machine, used by the onboarding model step.
         catalog = None
         try:
-            from latticeai.setup.auto_setup import probe as auto_setup_probe
             from latticeai.services.model_recommendation import recommend_catalog
+            from latticeai.setup.auto_setup import probe as auto_setup_probe
             profile = await asyncio.to_thread(lambda: auto_setup_probe().to_json())
             catalog = recommend_catalog(profile, engine="local_mlx")
         except Exception as exc:  # pragma: no cover - recommendation is best-effort