ltcai 10.0.0 → 10.3.0

package/latticeai/api/chat_documents.py

@@ -20,7 +20,11 @@ from latticeai.core.context_builder import (
     format_sources_footnote,
     retrieve_context_for_generation,
 )
-from latticeai.core.document_generator import DocumentGenerationSession, detect_document_intent
+from latticeai.core.document_generator import (
+    DocumentGenerationSession,
+    detect_document_intent,
+)
+from latticeai.core.quiet import quiet
 
 
 def extract_screenshot_context(image_data: Optional[str]) -> str:
@@ -77,7 +81,7 @@ def extract_screenshot_context(image_data: Optional[str]) -> str:
             try:
                 Path(temp_path).unlink()
             except OSError:
-                pass
+                quiet()
     return "\n".join(lines)
 
 

package/latticeai/api/chat_hybrid.py

@@ -0,0 +1,82 @@
+"""Chat-path helpers for hybrid cloud branching (Phase 2).
+
+Keeps the main chat router thin: resolve network mode, decide whether to
+enter the hybrid stream, and build the StreamingResponse.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from fastapi.responses import StreamingResponse
+
+from latticeai.core.network_boundary import (
+    NetworkBoundaryMode,
+    normalize_network_mode,
+)
+from latticeai.runtime.network_boundary_wiring import resolve_active_network_mode
+from latticeai.services.hybrid_chat import stream_hybrid_cloud_turn
+
+
+def resolve_request_network_mode(
+    *,
+    request_mode: Optional[str],
+    user_email: Optional[str],
+    workspace_id: Optional[str],
+) -> NetworkBoundaryMode:
+    """Per-request override wins; otherwise use the persisted dial."""
+    if request_mode:
+        return normalize_network_mode(request_mode)
+    return normalize_network_mode(
+        resolve_active_network_mode(user_email=user_email, workspace_id=workspace_id)
+    )
+
+
+def maybe_hybrid_stream_response(
+    *,
+    req: Any,
+    mode: NetworkBoundaryMode,
+    knowledge_graph: Any,
+    enable_graph: bool,
+    effective_email: Optional[str],
+    workspace_id: Optional[str],
+    history_meta: Dict[str, Any],
+    history_user: Dict[str, Any],
+    chat_service: Any,
+    notify: Any,
+    model_id: Optional[str],
+) -> Optional[StreamingResponse]:
+    """Return a StreamingResponse when cloud path should run; else None."""
+    if mode != NetworkBoundaryMode.CLOUD_ALLOWED:
+        return None
+    if not (enable_graph and knowledge_graph is not None):
+        # Without a graph there is nothing minimal to send; fall back to local.
+        return None
+
+    return StreamingResponse(
+        stream_hybrid_cloud_turn(
+            user_message=req.message,
+            knowledge_graph=knowledge_graph,
+            mode=mode,
+            workspace_id=workspace_id,
+            user_email=effective_email,
+            model=model_id,
+            chat_service=chat_service,
+            history_meta=history_meta,
+            history_user=history_user,
+            notify=notify,
+            source=req.source,
+        ),
+        media_type="text/event-stream",
+        headers={
+            "X-Model": model_id or "cloud",
+            "X-Network-Mode": mode.value,
+            "X-Hybrid": "1",
+        },
+    )
+
+
+__all__ = [
+    "resolve_request_network_mode",
+    "maybe_hybrid_stream_response",
+]

package/latticeai/api/computer_use.py

@@ -10,8 +10,8 @@ from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
-from latticeai.core.agent import extract_action as _extract_agent_action
 from lattice_brain.runtime.hooks import dispatch_tool
+from latticeai.core.agent import extract_action as _extract_agent_action
 from latticeai.services.tool_dispatch import enforce_tool_policy
 from latticeai.tools import (
     AGENT_ROOT,
@@ -30,7 +30,6 @@ from latticeai.tools import (
     execute_tool,
 )
 
-
 CU_SYSTEM_PROMPT = """You are Lattice AI desktop-control agent. You control the Mac desktop using tools.
 Prefer non-visual direct actions when possible. Use screenshots only when you must inspect visible UI state or choose screen coordinates.
 
@@ -438,7 +437,13 @@ def create_computer_use_router(
 
                 yield _send("action", {"step": step + 1, "action": name, "args": args})
                 try:
-                    result = _dispatch(name, args, lambda: execute_tool(name, args), current_user=current_user)
+                    result = _dispatch(
+                        name,
+                        args,
+                        # Bound as defaults; see chat_agent_http for why.
+                        lambda name=name, args=args: execute_tool(name, args),
+                        current_user=current_user,
+                    )
                     if name == "computer_screenshot" and "screenshot_b64" in result:
                         last_screenshot_b64 = result["screenshot_b64"]
                         result_summary = {k: v for k, v in result.items() if k != "screenshot_b64"}

package/latticeai/api/knowledge_graph.py

@@ -12,8 +12,8 @@ from typing import Any, Callable, Dict, List, Optional
 from fastapi import APIRouter, HTTPException, Request
 from pydantic import BaseModel
 
-from latticeai.api.ui_redirects import app_redirect
 from lattice_brain.ingestion import IngestionItem
+from latticeai.api.ui_redirects import app_redirect
 
 
 class KnowledgeGraphIngestRequest(BaseModel):

package/latticeai/api/mcp.py

@@ -17,17 +17,17 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional
 
-from lattice_brain.ingestion import IngestionItem
 from fastapi import APIRouter, HTTPException, Request
 from pydantic import BaseModel
 
 import latticeai.core.mcp_registry as mcp_registry
+from lattice_brain.ingestion import IngestionItem
 from latticeai.core.mcp_registry import (
-    _get_combined_registry,
-    _fetch_skills_marketplace,
+    SKILLS_DIR,
     _fetch_plugin_directory,
+    _fetch_skills_marketplace,
+    _get_combined_registry,
     install_skill,
-    SKILLS_DIR,
 )
 from latticeai.core.tool_registry import (
     KNOWLEDGE_WRITE_TOOLS,

package/latticeai/api/models.py

@@ -494,7 +494,10 @@ def create_models_router(
     async def load_model(req: LoadModelRequest, request: Request):
         current_user = _authorize_model_admin(request, req.user_email)
         try:
-            from latticeai.core.model_compat import friendly_model_runtime_error, model_runtime_compatibility
+            from latticeai.core.model_compat import (
+                friendly_model_runtime_error,
+                model_runtime_compatibility,
+            )
 
             model_id = req.model_id
             requested_engine = req.engine or (model_id.split(":", 1)[0] if ":" in model_id else "local_mlx")
@@ -552,8 +555,8 @@ def create_models_router(
         hardware, load_strategy, license, safety_notes) from the structured registry.
         """
         require_user(request)
-        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=engine)

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