ltcai 11.5.2 → 11.7.0

package/latticeai/services/run_executor.py

@@ -1,387 +0,0 @@
-"""Durable asyncio run executor for v4 Act runtimes.
-
-The executor owns server-loop tasks for agent and workflow runs while the
-workspace store remains the durable source of truth. Work is persisted before it
-starts, updated as it moves through queued/running/cancelling/final states, and
-reconciled on startup so orphaned active rows never masquerade as live work.
-"""
-
-from __future__ import annotations
-
-import asyncio
-from dataclasses import dataclass
-from typing import Any, Callable, Dict, Optional
-
-from lattice_brain.runtime.statuses import (
-    RUN_ACTIVE_STATUSES as ACTIVE_STATUSES,
-)
-from lattice_brain.workflow import WorkflowEngine
-from latticeai.core.quiet import quiet
-from latticeai.core.timeutil import now_iso as _now
-
-
-@dataclass
-class _RunHandle:
-    run_id: str
-    kind: str
-    scope: Optional[str]
-    task: Optional[asyncio.Task] = None
-    cancel_requested: bool = False
-    started: bool = False
-
-    def is_cancelled(self) -> bool:
-        """Read the flag through a call.
-
-        `cancel_requested` is set by a *different* task (``cancel``), so a
-        reader must not be narrowed by an earlier check in its own frame:
-        the value can change between the guard and the poll.
-        """
-        return self.cancel_requested
-
-
-class RunExecutor:
-    """Async task manager for persisted agent/workflow executions."""
-
-    def __init__(
-        self,
-        *,
-        store: Any,
-        agent_runtime: Any,
-        build_workflow_runners: Callable[[Optional[str], Optional[str]], Dict[str, Callable[..., Any]]],
-        workspace_graph: Callable[[], Any],
-        append_audit_event: Callable[..., None],
-        hooks: Any = None,
-        review_sink: Any = None,
-    ) -> None:
-        self.store = store
-        self.agent_runtime = agent_runtime
-        self.build_workflow_runners = build_workflow_runners
-        self.workspace_graph = workspace_graph
-        self.append_audit_event = append_audit_event
-        self.hooks = hooks
-        # Optional review-queue seam (5.6.0). Default None → no behavior change.
-        self.review_sink = review_sink
-        self._handles: Dict[str, _RunHandle] = {}
-        self._results: Dict[str, Dict[str, Any]] = {}
-
-    # ── startup reconciliation ───────────────────────────────────────────
-
-    def reconcile_startup(self) -> Dict[str, Any]:
-        return self.store.reconcile_interrupted_runs(reason="server_startup")
-
-    # ── agent runs ───────────────────────────────────────────────────────
-
-    async def start_agent(
-        self,
-        goal: str,
-        *,
-        user_email: Optional[str],
-        scope: Optional[str],
-        roles: Optional[list[str]] = None,
-        inputs: Optional[Dict[str, Any]] = None,
-        max_retries: int = 2,
-    ) -> Dict[str, Any]:
-        reserved = self.agent_runtime.reserve_run(
-            goal,
-            user_email=user_email,
-            scope=scope,
-            roles=roles,
-            inputs=inputs or {},
-            max_retries=max_retries,
-        )
-        run_id = reserved["run"]["id"]
-        handle = _RunHandle(run_id=run_id, kind="agent", scope=scope)
-        handle.task = asyncio.create_task(
-            self._run_agent(handle, goal, user_email=user_email, roles=roles, inputs=inputs or {}, max_retries=max_retries)
-        )
-        self._handles[run_id] = handle
-        return {
-            **reserved,
-            "execution_mode": "async",
-            "accepted": True,
-            "events_url": f"/agents/api/runs/{run_id}/events",
-            "stop_url": f"/agents/api/runs/{run_id}/stop",
-        }
-
-    async def _run_agent(
-        self,
-        handle: _RunHandle,
-        goal: str,
-        *,
-        user_email: Optional[str],
-        roles: Optional[list[str]],
-        inputs: Dict[str, Any],
-        max_retries: int,
-    ) -> None:
-        run_id = handle.run_id
-        try:
-            if handle.cancel_requested:
-                self._cancel_agent_record(run_id, handle.scope, "cancelled before execution started")
-                return
-            handle.started = True
-            payload = await asyncio.to_thread(
-                self.agent_runtime.complete_reserved_run,
-                run_id,
-                goal,
-                user_email=user_email,
-                scope=handle.scope,
-                roles=roles,
-                inputs=inputs,
-                max_retries=max_retries,
-                cancel_requested=handle.is_cancelled,
-            )
-            if handle.is_cancelled() and (payload.get("run") or {}).get("status") != "cancelled":
-                self._cancel_agent_record(run_id, handle.scope, "cancelled after the final result was persisted")
-            else:
-                self._results[run_id] = payload
-        except Exception as exc:
-            try:
-                run = self.store.get_agent_run(run_id, workspace_id=handle.scope)
-                timeline = list(run.get("timeline") or [])
-                timeline.append({"event": "execution_failed", "status": "failed", "detail": str(exc), "timestamp": _now()})
-                failed = self.store.update_agent_run(
-                    run_id,
-                    workspace_id=handle.scope,
-                    status="failed",
-                    current_role=None,
-                    output_text=str(exc),
-                    timeline=timeline,
-                    graph=self.workspace_graph(),
-                )
-                self._results[run_id] = {"run": failed, "result": {"status": "failed", "error": str(exc)}}
-            except Exception:
-                self._results[run_id] = {"run": {"id": run_id, "status": "failed"}, "result": {"status": "failed", "error": str(exc)}}
-            try:
-                self.append_audit_event("agent_run_failed", user_email=user_email, run_id=run_id, error=str(exc))
-            except Exception:
-                quiet()
-        finally:
-            self._handles.pop(run_id, None)
-
-    def _cancel_agent_record(self, run_id: str, scope: Optional[str], reason: str) -> Dict[str, Any]:
-        run = self.store.get_agent_run(run_id, workspace_id=scope)
-        timeline = list(run.get("timeline") or [])
-        timeline.append({"event": "execution_cancelled", "status": "cancelled", "reason": reason, "timestamp": _now()})
-        cancelled = self.store.update_agent_run(
-            run_id,
-            workspace_id=scope,
-            status="cancelled",
-            current_role=None,
-            cancel_reason=reason,
-            cancelled_at=_now(),
-            output_text=run.get("output_preview") or reason,
-            timeline=timeline,
-            graph=self.workspace_graph(),
-        )
-        payload = {"run": cancelled, "result": {"status": "cancelled", "reason": reason}}
-        self._results[run_id] = payload
-        return cancelled
-
-    # ── workflow runs ────────────────────────────────────────────────────
-
-    async def start_workflow(
-        self,
-        workflow: Dict[str, Any],
-        *,
-        workflow_id: str,
-        user_email: Optional[str],
-        scope: Optional[str],
-        inputs: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        run = self.store.record_workflow_run(
-            workflow_id=workflow_id,
-            name=workflow.get("name") or "workflow",
-            status="queued",
-            timeline=[{"event": "workflow_started", "status": "queued", "timestamp": _now()}],
-            outputs={},
-            user_email=user_email,
-            graph=None,
-            workspace_id=scope,
-            mode="live",
-        )
-        run = self.store.update_workflow_run(
-            run["id"],
-            workspace_id=scope,
-            execution_mode="async",
-            inputs=inputs or {},
-        )
-        handle = _RunHandle(run_id=run["id"], kind="workflow", scope=scope)
-        handle.task = asyncio.create_task(
-            self._run_workflow(handle, workflow, user_email=user_email, inputs=inputs or {})
-        )
-        self._handles[run["id"]] = handle
-        return {
-            "run": run,
-            "execution_mode": "async",
-            "accepted": True,
-            "events_url": f"/workflows/api/runs/{run['id']}/replay",
-            "stop_url": f"/workflows/api/runs/{run['id']}/stop",
-        }
-
-    async def _run_workflow(
-        self,
-        handle: _RunHandle,
-        workflow: Dict[str, Any],
-        *,
-        user_email: Optional[str],
-        inputs: Dict[str, Any],
-    ) -> None:
-        run_id = handle.run_id
-        try:
-            if handle.cancel_requested:
-                self._cancel_workflow_record(run_id, handle.scope, "cancelled before execution started")
-                return
-            handle.started = True
-            run = self.store.get_workflow_run(run_id, workspace_id=handle.scope)
-            base_timeline = list(run.get("timeline") or [])
-            self.store.update_workflow_run(
-                run_id,
-                workspace_id=handle.scope,
-                status="running",
-                started_at=run.get("started_at") or _now(),
-            )
-            result = await asyncio.to_thread(self._execute_workflow_sync, workflow, user_email, handle.scope, inputs)
-            if handle.is_cancelled():
-                self._cancel_workflow_record(run_id, handle.scope, "cancelled after the current synchronous step completed")
-                return
-            pause = (
-                {"node": result.paused_node, "pending": result.pending_approval, "context": result.paused_context}
-                if result.status == "awaiting_approval" else None
-            )
-            updated = self.store.update_workflow_run(
-                run_id,
-                workspace_id=handle.scope,
-                graph=self.workspace_graph(),
-                status=result.status,
-                timeline=base_timeline + list(result.timeline or []),
-                outputs=result.outputs,
-                pause=pause,
-            )
-            self.append_audit_event(
-                "workflow_run",
-                user_email=user_email,
-                workflow_id=workflow.get("id"),
-                status=result.status,
-            )
-            self._maybe_enqueue_review(
-                workflow,
-                run_result={"run": updated, "result": result.as_dict()},
-                user_email=user_email,
-                workspace_id=handle.scope,
-            )
-            self._results[run_id] = {"run": updated, "result": result.as_dict()}
-        except Exception as exc:
-            run = self.store.get_workflow_run(run_id, workspace_id=handle.scope)
-            timeline = list(run.get("timeline") or [])
-            timeline.append({"event": "execution_failed", "status": "failed", "detail": str(exc), "timestamp": _now()})
-            failed = self.store.update_workflow_run(
-                run_id,
-                workspace_id=handle.scope,
-                graph=self.workspace_graph(),
-                status="failed",
-                timeline=timeline,
-                outputs={"error": str(exc)},
-                pause=None,
-            )
-            self._results[run_id] = {"run": failed, "result": {"status": "failed", "error": str(exc)}}
-        finally:
-            self._handles.pop(run_id, None)
-
-    def _maybe_enqueue_review(
-        self,
-        workflow: Dict[str, Any],
-        *,
-        run_result: Dict[str, Any],
-        user_email: Optional[str],
-        workspace_id: Optional[str],
-    ) -> None:
-        if self.review_sink is None:
-            return
-        try:
-            from latticeai.services.review_queue import enqueue_from_automation
-
-            enqueue_from_automation(
-                self.review_sink,
-                workflow=workflow,
-                source="workflow_run",
-                run_result=run_result,
-                user_email=user_email,
-                workspace_id=workspace_id,
-            )
-        except Exception:
-            quiet()
-
-    def _execute_workflow_sync(
-        self,
-        workflow: Dict[str, Any],
-        user_email: Optional[str],
-        scope: Optional[str],
-        inputs: Dict[str, Any],
-    ) -> Any:
-        runners = self.build_workflow_runners(user_email, scope)
-        return WorkflowEngine(runners, hooks=self.hooks).run(workflow, inputs=inputs)
-
-    def _cancel_workflow_record(self, run_id: str, scope: Optional[str], reason: str) -> Dict[str, Any]:
-        run = self.store.get_workflow_run(run_id, workspace_id=scope)
-        timeline = list(run.get("timeline") or [])
-        timeline.append({"event": "execution_cancelled", "status": "cancelled", "reason": reason, "timestamp": _now()})
-        cancelled = self.store.update_workflow_run(
-            run_id,
-            workspace_id=scope,
-            status="cancelled",
-            cancel_reason=reason,
-            cancelled_at=_now(),
-            timeline=timeline,
-            pause=None,
-            graph=self.workspace_graph(),
-        )
-        payload = {"run": cancelled, "result": {"status": "cancelled", "reason": reason}}
-        self._results[run_id] = payload
-        return cancelled
-
-    # ── cancellation/status ──────────────────────────────────────────────
-
-    def cancel(self, run_id: str, *, kind: Optional[str] = None, scope: Optional[str] = None) -> Dict[str, Any]:
-        handle = self._handles.get(run_id)
-        try:
-            run = (
-                self.store.get_workflow_run(run_id, workspace_id=scope)
-                if kind == "workflow" or (handle and handle.kind == "workflow")
-                else self.store.get_agent_run(run_id, workspace_id=scope)
-            )
-        except FileNotFoundError:
-            return {"stopped": False, "reason": "run not found", "run_id": run_id}
-
-        status = str(run.get("status") or "")
-        if status not in ACTIVE_STATUSES:
-            return {"stopped": False, "reason": "run already finished", "run_id": run_id, "status": status}
-
-        if handle is not None:
-            handle.cancel_requested = True
-        target_kind = (kind or (handle.kind if handle else "agent"))
-        updater = self.store.update_workflow_run if target_kind == "workflow" else self.store.update_agent_run
-        updater(
-            run_id,
-            workspace_id=scope,
-            status="cancelling",
-            cancel_requested=True,
-            cancel_requested_at=_now(),
-        )
-        if handle is None:
-            if target_kind == "workflow":
-                self._cancel_workflow_record(run_id, scope, "cancelled; no active worker owned this run")
-            else:
-                self._cancel_agent_record(run_id, scope, "cancelled; no active worker owned this run")
-        return {
-            "stopped": True,
-            "run_id": run_id,
-            "status": "cancelling" if handle is not None else "cancelled",
-            "cancellation": "cooperative",
-            "reason": "cancellation requested; synchronous work finishes its current step before the final cancelled status is stored",
-        }
-
-    async def wait(self, run_id: str, *, timeout: Optional[float] = None) -> Optional[Dict[str, Any]]:
-        handle = self._handles.get(run_id)
-        if handle and handle.task:
-            await asyncio.wait_for(handle.task, timeout=timeout)
-        return self._results.get(run_id)

package/latticeai/services/self_model_service.py

@@ -1,171 +0,0 @@
-"""Self-Model service — the Brain's profile of its owner (v11.1.0 Track 4).
-
-Router-facing façade over :mod:`lattice_brain.self_model`. It owns two things
-the Brain Core deliberately does not:
-
-* **where the collaborators come from.** The knowledge graph and the review
-  queue are read off the ``MemoryService`` the memory router already holds
-  (the same ``WorkspaceOSStore`` every other ``ReviewQueueService`` in the
-  process is built over), so the Self-Model routes need no extra wiring at the
-  composition root and proposals land in the one inbox the user reads.
-* **what "unavailable" means.** A Brain with the graph disabled reports
-  ``available: False`` with a reason instead of pretending it has no profile,
-  and a write attempted without a graph raises so the API answers 409 rather
-  than silently doing nothing.
-
-The consent model is the product's: extraction proposes, the user approves,
-and only the *user's own* edits write directly.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-from lattice_brain.self_model import (
-    DEFAULT_SUMMARY_TOKENS,
-    KIND_ORDER,
-    SelfModelError,
-    apply_self_model_proposal,
-    delete_self_model_fact,
-    list_self_model,
-    propose_self_model,
-    self_model_summary,
-    upsert_self_model_fact,
-)
-from latticeai.core.timeutil import now_iso as _now
-
-GRAPH_UNAVAILABLE = "self-model needs the knowledge graph"
-QUEUE_UNAVAILABLE = "self-model proposals need the review queue"
-
-
-class SelfModelService:
-    """Read/propose/apply/edit the Self-Model subgraph."""
-
-    def __init__(
-        self,
-        *,
-        memory_service: Any = None,
-        knowledge_graph: Any = None,
-        review_queue: Any = None,
-        enable_graph: bool = True,
-        summary_tokens: int = DEFAULT_SUMMARY_TOKENS,
-    ) -> None:
-        self._memory = memory_service
-        self._graph = knowledge_graph
-        self._queue = review_queue
-        self._enable_graph = bool(enable_graph)
-        self._summary_tokens = int(summary_tokens)
-
-    # ── collaborators ────────────────────────────────────────────────────
-    def _kg(self) -> Any:
-        """The knowledge graph, or ``None`` when this Brain has none."""
-        if not self._enable_graph:
-            return None
-        if self._graph is None:
-            self._graph = getattr(self._memory, "_kg", None)
-        return self._graph
-
-    def _review_queue(self) -> Any:
-        """The review queue proposals are written to, or ``None``."""
-        if self._queue is not None:
-            return self._queue
-        store = getattr(self._memory, "_store", None)
-        if store is None or not hasattr(store, "create_review_item"):
-            return None
-        from latticeai.services.review_queue import ReviewQueueService
-
-        self._queue = ReviewQueueService(store=store)
-        return self._queue
-
-    @staticmethod
-    def _unavailable(detail: str) -> Dict[str, Any]:
-        return {"available": False, "detail": detail, "generated_at": _now()}
-
-    def _require_graph(self) -> Any:
-        graph = self._kg()
-        if graph is None:
-            raise SelfModelError(GRAPH_UNAVAILABLE, code="graph_unavailable")
-        return graph
-
-    # ── reads ────────────────────────────────────────────────────────────
-    def profile(
-        self, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None
-    ) -> Dict[str, Any]:
-        """Everything the Brain holds about its owner, plus the injected text."""
-        graph = self._kg()
-        if graph is None:
-            return {**self._unavailable(GRAPH_UNAVAILABLE), "facts": [], "summary": ""}
-        listing = dict(list_self_model(graph, workspace_id=workspace_id))
-        listing["summary"] = self_model_summary(
-            graph, limit_tokens=self._summary_tokens, workspace_id=workspace_id
-        )
-        listing["summary_tokens"] = self._summary_tokens
-        listing["user_email"] = user_email
-        listing["kind_options"] = list(KIND_ORDER)
-        return listing
-
-    def summary(self, *, workspace_id: Optional[str] = None) -> str:
-        """Injection-ready summary (empty string when there is nothing to say)."""
-        graph = self._kg()
-        if graph is None:
-            return ""
-        return self_model_summary(
-            graph, limit_tokens=self._summary_tokens, workspace_id=workspace_id
-        )
-
-    # ── proposal path (agents / background) ──────────────────────────────
-    def propose(
-        self,
-        text: str,
-        *,
-        texts: Optional[List[str]] = None,
-        source: Optional[str] = None,
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-        max_proposals: int = 5,
-    ) -> Dict[str, Any]:
-        """Read text and raise a review proposal per new fact. Never writes."""
-        graph = self._kg()
-        if graph is None:
-            return self._unavailable(GRAPH_UNAVAILABLE)
-        queue = self._review_queue()
-        if queue is None:
-            return self._unavailable(QUEUE_UNAVAILABLE)
-        return propose_self_model(
-            graph,
-            queue,
-            text=text,
-            texts=texts,
-            source=source,
-            workspace_id=workspace_id,
-            user_email=user_email,
-            max_proposals=max_proposals,
-        )
-
-    def apply(
-        self, item_id: str, *, workspace_id: Optional[str] = None
-    ) -> Dict[str, Any]:
-        """Approve one Self-Model proposal and write the fact into the graph."""
-        graph = self._require_graph()
-        queue = self._review_queue()
-        if queue is None:
-            raise SelfModelError(QUEUE_UNAVAILABLE, code="queue_unavailable")
-        return apply_self_model_proposal(
-            graph, queue, item_id, workspace_id=workspace_id
-        )
-
-    # ── user-initiated edits (direct) ────────────────────────────────────
-    def upsert(
-        self, *, kind: str, text: str, workspace_id: Optional[str] = None
-    ) -> Dict[str, Any]:
-        """A person editing their own profile writes straight through."""
-        return upsert_self_model_fact(
-            self._require_graph(), kind=kind, text=text, workspace_id=workspace_id
-        )
-
-    def delete(self, node_id: str) -> Dict[str, Any]:
-        """Forget one fact about the user, permanently."""
-        return delete_self_model_fact(self._require_graph(), node_id)
-
-
-__all__ = ["GRAPH_UNAVAILABLE", "QUEUE_UNAVAILABLE", "SelfModelService"]