ltcai 9.9.5 → 9.9.9

package/latticeai/api/project_sessions.py

@@ -0,0 +1,112 @@
+"""Project session router — the multi-turn project loop (v9.9.6).
+
+CRUD over :class:`~latticeai.core.project_sessions.ProjectSessionStore`. A
+project session carries what a single agent run cannot: the files the project
+already produced, what is still open, and the last honest verification result.
+Runs fold themselves in through the agent HTTP layer; this surface is what the
+user drives.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, List, Optional
+
+from fastapi import APIRouter, HTTPException, Request
+from pydantic import BaseModel, Field
+
+
+class CreateProjectRequest(BaseModel):
+    title: str = Field(..., min_length=1, max_length=200)
+    goal: str = ""
+
+
+class UpdateProjectRequest(BaseModel):
+    title: Optional[str] = None
+    goal: Optional[str] = None
+    status: Optional[str] = None
+
+
+class TodosRequest(BaseModel):
+    todos: List[Any] = Field(default_factory=list)
+
+
+def create_project_sessions_router(
+    *,
+    store: Any,
+    require_user: Callable[[Request], Any],
+    gate_read: Optional[Callable[[Request], Optional[str]]] = None,
+    gate_write: Optional[Callable[[Request], Optional[str]]] = None,
+) -> APIRouter:
+    router = APIRouter()
+
+    def _scope(request: Request, write: bool = False):
+        gate = gate_write if write else gate_read
+        return gate(request) if gate is not None else None
+
+    @router.get("/api/projects")
+    async def list_projects(request: Request, status: str = "active"):
+        user = require_user(request)
+        return store.list(
+            user_email=user, workspace_id=_scope(request), status=status
+        )
+
+    @router.post("/api/projects")
+    async def create_project(req: CreateProjectRequest, request: Request):
+        user = require_user(request)
+        return store.create(
+            title=req.title,
+            goal=req.goal,
+            user_email=user,
+            workspace_id=_scope(request, write=True),
+        )
+
+    @router.get("/api/projects/{session_id}")
+    async def get_project(session_id: str, request: Request):
+        user = require_user(request)
+        record = store.get(session_id, user_email=user, workspace_id=_scope(request))
+        if record is None:
+            raise HTTPException(status_code=404, detail="project not found")
+        return record
+
+    @router.patch("/api/projects/{session_id}")
+    async def update_project(session_id: str, req: UpdateProjectRequest, request: Request):
+        user = require_user(request)
+        record = store.update(
+            session_id,
+            title=req.title,
+            goal=req.goal,
+            status=req.status,
+            user_email=user,
+            workspace_id=_scope(request, write=True),
+        )
+        if record is None:
+            raise HTTPException(status_code=404, detail="project not found")
+        return record
+
+    @router.put("/api/projects/{session_id}/todos")
+    async def set_todos(session_id: str, req: TodosRequest, request: Request):
+        user = require_user(request)
+        record = store.set_todos(
+            session_id,
+            req.todos,
+            user_email=user,
+            workspace_id=_scope(request, write=True),
+        )
+        if record is None:
+            raise HTTPException(status_code=404, detail="project not found")
+        return record
+
+    @router.delete("/api/projects/{session_id}")
+    async def delete_project(session_id: str, request: Request):
+        user = require_user(request)
+        removed = store.delete(
+            session_id, user_email=user, workspace_id=_scope(request, write=True)
+        )
+        if not removed:
+            raise HTTPException(status_code=404, detail="project not found")
+        return {"status": "deleted", "id": session_id}
+
+    return router
+
+
+__all__ = ["create_project_sessions_router"]

package/latticeai/api/voice_capture.py

@@ -0,0 +1,89 @@
+"""Voice memo capture router (v9.9.7).
+
+``GET  /api/capture/voice/status`` — what this install can actually do with a
+voice memo (capture always; transcription only when a local transcriber
+exists).
+
+``POST /api/capture/voice`` — ingest one memo (multipart upload) through the
+unified ingestion pipeline. Local-only: audio is written to the workspace data
+dir and transcribed on this machine or not at all.
+"""
+
+from __future__ import annotations
+
+import logging
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+from fastapi import APIRouter, File, Form, HTTPException, Request, UploadFile
+
+LOGGER = logging.getLogger(__name__)
+
+
+def create_voice_capture_router(
+    *,
+    service: Any,
+    require_user: Callable[[Request], Any],
+    gate_write: Optional[Callable[[Request], Optional[str]]] = None,
+    append_audit_event: Optional[Callable[..., None]] = None,
+) -> APIRouter:
+    router = APIRouter()
+
+    @router.get("/api/capture/voice/status")
+    async def voice_status(request: Request):
+        require_user(request)
+        return service.status()
+
+    @router.post("/api/capture/voice")
+    async def voice_capture(
+        request: Request,
+        file: UploadFile = File(...),
+        title: str = Form(""),
+        transcript: str = Form(""),
+        conversation_id: str = Form(""),
+    ):
+        user = require_user(request)
+        scope = gate_write(request) if gate_write is not None else None
+        suffix = Path(file.filename or "memo.m4a").suffix or ".m4a"
+        tmp_path: Optional[Path] = None
+        try:
+            with tempfile.NamedTemporaryFile(
+                prefix="ltcai-voice-", suffix=suffix, delete=False
+            ) as handle:
+                shutil.copyfileobj(file.file, handle)
+                tmp_path = Path(handle.name)
+            result = service.capture(
+                str(tmp_path),
+                title=title or Path(file.filename or "").stem,
+                user_email=user,
+                workspace_id=scope,
+                conversation_id=conversation_id or None,
+                transcript=transcript or None,
+            )
+        except Exception as exc:  # noqa: BLE001 — surface a clean error, not a 500 trace
+            LOGGER.exception("voice capture failed")
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+        finally:
+            if tmp_path is not None:
+                try:
+                    tmp_path.unlink(missing_ok=True)
+                except OSError:
+                    pass
+        if append_audit_event is not None:
+            try:
+                append_audit_event(
+                    "voice_capture",
+                    user_email=user,
+                    status=result.get("status"),
+                    transcription=result.get("transcription"),
+                )
+            except Exception:  # noqa: BLE001 — audit is advisory
+                LOGGER.debug("voice capture audit failed", exc_info=True)
+        return result
+
+    return router
+
+
+__all__ = ["create_voice_capture_router"]

package/latticeai/app_factory.py

@@ -857,6 +857,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     SEARCH_SERVICE = _context_runtime["SEARCH_SERVICE"]
     BRAIN_MEMORY = _context_runtime["BRAIN_MEMORY"]
     CONTEXT_ASSEMBLER = _context_runtime["CONTEXT_ASSEMBLER"]
+    ARTIFACT_LEDGER = _context_runtime["ARTIFACT_LEDGER"]
     _scoped_hybrid_search = _context_runtime["_scoped_hybrid_search"]
 
 
@@ -911,6 +912,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         local_kg_watcher=LOCAL_KG_WATCHER,
         chat_service=CHAT_SERVICE,
         context_assembler=CONTEXT_ASSEMBLER,
+        artifact_ledger=ARTIFACT_LEDGER,
         brain_memory=BRAIN_MEMORY,
         ingestion_pipeline=INGESTION_PIPELINE if ENABLE_GRAPH else None,
         chat_agent_runtime=CHAT_AGENT_RUNTIME,
@@ -1149,6 +1151,57 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
             return None
         return PLATFORM.allowed_scopes(user)
 
+    # Evidence → action (v9.9.6): an answer's citations become ready-to-send,
+    # evidence-scoped follow-ups. Deterministic composition only — execution
+    # stays on the chat/file-generation path.
+    from latticeai.api.evidence_actions import create_evidence_actions_router
+    from latticeai.services.evidence_actions import EvidenceActionService
+
+    EVIDENCE_ACTIONS_SERVICE = EvidenceActionService(
+        node_reader=getattr(KNOWLEDGE_GRAPH, "get_node", None)
+    )
+    app.include_router(
+        create_evidence_actions_router(
+            service=EVIDENCE_ACTIONS_SERVICE,
+            require_user=require_user,
+            allowed_workspaces_for=_allowed_workspaces_for,
+        )
+    )
+
+    # Voice memo capture (v9.9.7): the shortest path from a thought to the
+    # Brain. Transcription is an optional local port — absent, the memo is
+    # still stored and the response says it is not searchable.
+    from latticeai.api.voice_capture import create_voice_capture_router
+    from latticeai.services.voice_capture import VoiceCaptureService
+
+    VOICE_CAPTURE = VoiceCaptureService(
+        pipeline=INGESTION_PIPELINE if ENABLE_GRAPH else None,
+        transcriber=None,
+    )
+    app.include_router(
+        create_voice_capture_router(
+            service=VOICE_CAPTURE,
+            require_user=require_user,
+            gate_write=PLATFORM.gate_write,
+            append_audit_event=append_audit_event,
+        )
+    )
+
+    # Multi-turn project loop (v9.9.6): work that spans several runs keeps its
+    # files, open TODOs, and last honest verification in one project session.
+    from latticeai.api.project_sessions import create_project_sessions_router
+    from latticeai.core.project_sessions import ProjectSessionStore
+
+    PROJECT_SESSIONS = ProjectSessionStore(DATA_DIR / "project_sessions")
+    app.include_router(
+        create_project_sessions_router(
+            store=PROJECT_SESSIONS,
+            require_user=require_user,
+            gate_read=PLATFORM.gate_read,
+            gate_write=PLATFORM.gate_write,
+        )
+    )
+
     tool_router_context, interaction_router_context = build_interaction_contexts(
         config=CONFIG,
         ingestion_pipeline=INGESTION_PIPELINE,