ltcai 11.5.2 → 11.7.0

package/latticeai/api/memory.py

@@ -1,270 +0,0 @@
-"""Memory platform + Memory Manager API router (v3.2.0).
-
-Exposes :class:`~latticeai.services.memory_service.MemoryService` so the /app
-Memory view can inspect every memory tier, recall across them, and run manager
-operations (prune / compact / rebuild / clear). Full paths in decorators.
-
-v11.1.0 adds the Self-Model surface (Track 4) on the same factory: the profile
-the Brain holds about its owner is *memory*, so it is read, edited and deleted
-here rather than behind a router of its own. Ownership is the whole point —
-extraction only ever proposes (``/self-model/propose`` →  Review Center →
-``/self-model/apply``), while the user's own edits and deletions write
-directly.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Callable, List, Optional
-
-from fastapi import APIRouter, HTTPException, Request
-from pydantic import BaseModel
-
-from lattice_brain.self_model import SelfModelError
-from latticeai.core.messages import http_error, resolve_language
-from latticeai.services.memory_service import MemoryService
-from latticeai.services.self_model_service import SelfModelService
-
-
-class RecallRequest(BaseModel):
-    query: str = ""
-    limit: int = 20
-
-
-class PruneRequest(BaseModel):
-    ids: List[str] = []
-    kind: Optional[str] = None
-
-
-class RebuildRequest(BaseModel):
-    target: str = "vector"
-
-
-class ClearRequest(BaseModel):
-    scope: str
-    confirm: bool = False
-
-
-#: Self-Model failure codes → catalog ids. Brain Core raises codes (it cannot
-#: import the catalog); the answer a person reads is chosen here, in their
-#: language. An unknown code degrades to the generic entry rather than leaking
-#: an English developer sentence.
-SELF_MODEL_MESSAGES = {
-    "invalid_kind": "self_model.invalid_kind",
-    "text_required": "self_model.text_required",
-    "not_found": "self_model.not_found",
-    "not_self_model": "self_model.not_self_model",
-    "not_a_proposal": "self_model.not_a_proposal",
-    "empty_proposal": "self_model.empty_proposal",
-    "graph_unavailable": "self_model.graph_unavailable",
-    "queue_unavailable": "self_model.queue_unavailable",
-}
-
-
-def _self_model_error(exc: SelfModelError, request: Request) -> HTTPException:
-    status = 404 if exc.code == "not_found" else 400
-    message_id = SELF_MODEL_MESSAGES.get(exc.code, "self_model.invalid")
-    return http_error(status, message_id, resolve_language(request))
-
-
-class SelfModelFactRequest(BaseModel):
-    """A fact the user states about themselves (user-initiated direct write)."""
-
-    kind: str
-    text: str
-
-
-class SelfModelProposeRequest(BaseModel):
-    """Text to read for candidate facts. Output is proposals, never writes."""
-
-    text: str = ""
-    source: str = ""
-    max_proposals: int = 5
-
-
-class SelfModelApplyRequest(BaseModel):
-    """Approve one Self-Model proposal and write the fact it carries."""
-
-    item_id: str
-
-
-def create_memory_router(
-    *,
-    service: MemoryService,
-    require_user: Callable[[Request], str],
-    get_current_user: Callable[[Request], Optional[str]],
-    gate_read: Callable[[Request], Optional[str]],
-    gate_write: Callable[[Request], Optional[str]],
-    append_audit_event: Callable[..., None],
-    active_model_getter: Callable[[], str] | None = None,
-    self_model: Any = None,
-) -> APIRouter:
-    router = APIRouter()
-    # Derived from the memory service by default (graph + review queue), so the
-    # Self-Model routes exist on every build and report honestly when this
-    # Brain has no graph rather than disappearing from the API surface.
-    profile = self_model or SelfModelService(memory_service=service)
-
-    @router.get("/api/memory/manager")
-    async def memory_manager(request: Request):
-        user = require_user(request)
-        scope = gate_read(request)
-        return service.manager(user_email=user, workspace_id=scope)
-
-    @router.get("/api/memory/brain-quality")
-    async def brain_quality_summary(request: Request):
-        user = require_user(request)
-        scope = gate_read(request)
-        return service.brain_quality_summary(user_email=user, workspace_id=scope)
-
-    @router.get("/api/memory/brain-brief")
-    async def brain_brief(request: Request, q: str = "", limit: int = 3):
-        user = require_user(request)
-        scope = gate_read(request)
-        active_model = active_model_getter() if active_model_getter else ""
-        return service.brain_brief(
-            user_email=user,
-            workspace_id=scope,
-            active_model=active_model,
-            recall_query=q,
-            limit=limit,
-        )
-
-    @router.get("/api/memory/brain-proof")
-    async def brain_proof(request: Request, q: str = "", limit: int = 3):
-        user = require_user(request)
-        scope = gate_read(request)
-        active_model = active_model_getter() if active_model_getter else ""
-        return service.brain_proof(
-            user_email=user,
-            workspace_id=scope,
-            active_model=active_model,
-            recall_query=q,
-            limit=limit,
-        )
-
-    @router.get("/api/memory/tiers")
-    async def memory_tiers(request: Request):
-        require_user(request)
-        return service.tiers()
-
-    @router.get("/api/memory/inspect")
-    async def memory_inspect(request: Request, source: str, limit: int = 50):
-        user = require_user(request)
-        scope = gate_read(request)
-        try:
-            return service.inspect(source, user_email=user, workspace_id=scope, limit=limit)
-        except KeyError as exc:
-            raise http_error(404, "memory.unknown_source", resolve_language(request), source=source) from exc
-
-    @router.post("/api/memory/recall")
-    async def memory_recall(req: RecallRequest, request: Request):
-        user = require_user(request)
-        scope = gate_read(request)
-        return service.recall(req.query, user_email=user, workspace_id=scope, limit=req.limit)
-
-    @router.post("/api/memory/prune")
-    async def memory_prune(req: PruneRequest, request: Request):
-        user = require_user(request)
-        scope = gate_write(request)
-        result = service.prune(ids=req.ids, kind=req.kind, user_email=user, workspace_id=scope)
-        append_audit_event("memory_prune", user_email=user, count=result.get("count", 0))
-        return result
-
-    @router.post("/api/memory/compact")
-    async def memory_compact(request: Request):
-        user = require_user(request)
-        scope = gate_write(request)
-        result = service.compact(user_email=user, workspace_id=scope)
-        append_audit_event("memory_compact", user_email=user, compacted=result.get("compacted", 0))
-        return result
-
-    @router.post("/api/memory/rebuild")
-    async def memory_rebuild(req: RebuildRequest, request: Request):
-        user = require_user(request)
-        gate_write(request)
-        result = service.rebuild(req.target)
-        append_audit_event("memory_rebuild", user_email=user, target=req.target, status=result.get("status"))
-        return result
-
-    @router.post("/api/memory/clear")
-    async def memory_clear(req: ClearRequest, request: Request):
-        user = require_user(request)
-        scope = gate_write(request)
-        try:
-            result = service.clear(scope=req.scope, confirm=req.confirm, user_email=user, workspace_id=scope)
-        except ValueError as exc:
-            raise HTTPException(status_code=400, detail=str(exc)) from exc
-        append_audit_event("memory_clear", user_email=user, scope=req.scope)
-        return result
-
-    # ── Self-Model (v11.1.0) ─────────────────────────────────────────────
-
-    @router.get("/api/memory/self-model")
-    async def self_model_profile(request: Request):
-        """What the Brain believes about its owner, and the injected summary."""
-        user = require_user(request)
-        scope = gate_read(request)
-        return profile.profile(user_email=user, workspace_id=scope)
-
-    @router.post("/api/memory/self-model")
-    async def self_model_upsert(req: SelfModelFactRequest, request: Request):
-        """Add or correct one fact directly — the user owns their profile."""
-        user = require_user(request)
-        scope = gate_write(request)
-        try:
-            fact = profile.upsert(kind=req.kind, text=req.text, workspace_id=scope)
-        except SelfModelError as exc:
-            raise _self_model_error(exc, request) from exc
-        append_audit_event(
-            "self_model_upsert", user_email=user, node_id=fact["id"], kind=fact["kind"]
-        )
-        return fact
-
-    @router.delete("/api/memory/self-model/{node_id}")
-    async def self_model_delete(node_id: str, request: Request):
-        """Forget one fact about the user, permanently."""
-        user = require_user(request)
-        gate_write(request)
-        try:
-            result = profile.delete(node_id)
-        except SelfModelError as exc:
-            raise _self_model_error(exc, request) from exc
-        append_audit_event("self_model_delete", user_email=user, node_id=node_id)
-        return result
-
-    @router.post("/api/memory/self-model/propose")
-    async def self_model_propose(req: SelfModelProposeRequest, request: Request):
-        """Read text for candidate facts; every hit becomes a review proposal."""
-        user = require_user(request)
-        scope = gate_write(request)
-        result = profile.propose(
-            req.text,
-            source=req.source or None,
-            user_email=user,
-            workspace_id=scope,
-            max_proposals=req.max_proposals,
-        )
-        append_audit_event(
-            "self_model_proposed",
-            user_email=user,
-            proposed=result.get("proposed_count", 0),
-        )
-        return result
-
-    @router.post("/api/memory/self-model/apply")
-    async def self_model_apply(req: SelfModelApplyRequest, request: Request):
-        """Approve a proposal and write the fact it carries into the graph."""
-        user = require_user(request)
-        scope = gate_write(request)
-        try:
-            result = profile.apply(req.item_id, workspace_id=scope)
-        except SelfModelError as exc:
-            raise _self_model_error(exc, request) from exc
-        except (KeyError, FileNotFoundError) as exc:
-            raise http_error(404, "review.item_not_found", resolve_language(request)) from exc
-        append_audit_event(
-            "self_model_applied", user_email=user, item_id=req.item_id
-        )
-        return result
-
-    return router

package/latticeai/api/network.py

@@ -1,81 +0,0 @@
-"""Brain Network API — device identity, peer pairing, knowledge exchange.
-
-The /network/receive endpoint authenticates PEERS (signed device requests),
-not user sessions; everything else requires a logged-in user, and pairing /
-pushing are deliberate owner actions.
-"""
-
-from __future__ import annotations
-
-from typing import Optional
-
-from fastapi import APIRouter, HTTPException, Request
-from pydantic import BaseModel
-
-
-class PeerPairRequest(BaseModel):
-    name: str
-    base_url: str
-    public_key: str
-
-
-class PeerPushRequest(BaseModel):
-    workspace_id: Optional[str] = None
-
-
-def create_network_router(*, network, identity, require_user, require_admin) -> APIRouter:
-    router = APIRouter()
-
-    @router.get("/network/identity")
-    async def network_identity(request: Request):
-        require_user(request)
-        return identity.describe()
-
-    @router.get("/network/peers")
-    async def network_peers(request: Request):
-        require_admin(request)
-        return {"peers": network.list_peers()}
-
-    @router.post("/network/peers")
-    async def network_pair(req: PeerPairRequest, request: Request):
-        require_admin(request)
-        try:
-            return {"status": "paired", "peer": network.add_peer(
-                name=req.name, base_url=req.base_url, public_key=req.public_key,
-            )}
-        except ValueError as exc:
-            raise HTTPException(status_code=400, detail=str(exc)) from exc
-
-    @router.delete("/network/peers/{peer_id}")
-    async def network_unpair(peer_id: str, request: Request):
-        require_admin(request)
-        try:
-            return network.remove_peer(peer_id)
-        except FileNotFoundError as exc:
-            raise HTTPException(status_code=404, detail=f"Unknown peer: {exc}") from exc
-
-    @router.post("/network/push/{peer_id}")
-    async def network_push(peer_id: str, req: PeerPushRequest, request: Request):
-        require_admin(request)
-        try:
-            return network.push_to_peer(peer_id, workspace_id=req.workspace_id)
-        except FileNotFoundError as exc:
-            raise HTTPException(status_code=404, detail=f"Unknown peer: {exc}") from exc
-        except Exception as exc:
-            raise HTTPException(status_code=502, detail=f"Push failed: {exc}") from exc
-
-    @router.post("/network/receive")
-    async def network_receive(request: Request):
-        # Peer-authenticated: a paired device's signature replaces the session.
-        body = await request.body()
-        try:
-            return network.receive(dict(request.headers), body)
-        except PermissionError as exc:
-            raise HTTPException(status_code=403, detail=str(exc)) from exc
-        except ValueError as exc:
-            raise HTTPException(status_code=400, detail=str(exc)) from exc
-
-    return router
-
-
-__all__ = ["create_network_router"]

package/latticeai/api/network_boundary.py

@@ -1,225 +0,0 @@
-"""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.messages import http_error, resolve_language, translate
-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 http_error(501, "common.graph_unavailable", resolve_language(request))
-        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 translate("graph.node_not_found", resolve_language(request)),
-            )
-        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 http_error(501, "boundary.policy_not_configured", resolve_language(request))
-        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 http_error(501, "boundary.policy_not_configured", resolve_language(request))
-        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/permission_mode.py

@@ -1,61 +0,0 @@
-"""Permission mode API — strict / trusted / bypass dial (v9.9.8)."""
-
-from __future__ import annotations
-
-from typing import Callable, Optional
-
-from fastapi import APIRouter, HTTPException, Request
-from pydantic import BaseModel, Field
-
-from latticeai.core.permission_mode import mode_catalog, normalize_mode
-from latticeai.services.permission_mode_service import PermissionModeService
-
-
-class SetPermissionModeRequest(BaseModel):
-    mode: str = Field(..., description="strict | trusted | bypass")
-    workspace_id: Optional[str] = None
-    acknowledge_risk: bool = False
-
-
-def create_permission_mode_router(
-    *,
-    service: PermissionModeService,
-    require_user: Callable[..., str],
-) -> APIRouter:
-    router = APIRouter(tags=["permission-mode"])
-
-    @router.get("/api/permission-mode")
-    async def get_permission_mode(
-        request: Request,
-        workspace_id: Optional[str] = None,
-    ):
-        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 service.get(user_email=user, workspace_id=scope)
-
-    @router.get("/api/permission-mode/catalog")
-    async def permission_mode_catalog(request: Request):
-        require_user(request)
-        return {"modes": mode_catalog()}
-
-    @router.post("/api/permission-mode")
-    async def set_permission_mode(body: SetPermissionModeRequest, request: Request):
-        user = require_user(request)
-        header_ws = request.headers.get("X-Workspace-Id")
-        scope = body.workspace_id or (header_ws.strip() if header_ws else None)
-        try:
-            return service.set_mode(
-                normalize_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
-
-    return router
-
-
-__all__ = ["create_permission_mode_router", "SetPermissionModeRequest"]