aethergraph 0.1.0a1__py3-none-any.whl → 0.1.0a2__py3-none-any.whl

aethergraph/services/memory/factory.py

@@ -5,7 +5,9 @@ from typing import Any
 
 from aethergraph.contracts.services.artifacts import AsyncArtifactStore  # generic protocol
 from aethergraph.contracts.services.memory import HotLog, Indices, Persistence
+from aethergraph.contracts.storage.doc_store import DocStore
 from aethergraph.services.memory.facade import MemoryFacade
+from aethergraph.services.scope.scope import Scope
 
 """
     # --- Artifacts (async FS store)
@@ -45,9 +47,10 @@ class MemoryFactory:
     persistence: Persistence
     indices: Indices  # key-value backed indices for fast lookups, not artifact storage index
     artifacts: AsyncArtifactStore
+    docs: DocStore  # document store for RAG
     hot_limit: int = 1000
     hot_ttl_s: int = 7 * 24 * 3600
-    default_signal_threshold: float = 0.25
+    default_signal_threshold: float = 0.0
     logger: Any | None = None
     llm_service: Any | None = None  # LLMService
     rag_facade: Any | None = None  # RAGFacade
@@ -58,16 +61,19 @@ class MemoryFactory:
         *,
         graph_id: str | None = None,
         node_id: str | None = None,
-        agent_id: str | None = None,
+        session_id: str | None = None,
+        scope: Scope | None = None,
     ) -> MemoryFacade:
         return MemoryFacade(
             run_id=run_id,
             graph_id=graph_id,
+            session_id=session_id,
             node_id=node_id,
-            agent_id=agent_id,
+            scope=scope,
             hotlog=self.hotlog,
             persistence=self.persistence,
             indices=self.indices,
+            docs=self.docs,
             artifact_store=self.artifacts,
             hot_limit=self.hot_limit,
             hot_ttl_s=self.hot_ttl_s,

aethergraph/services/memory/utils.py

@@ -0,0 +1,10 @@
+def _summary_prefix(scope_id: str, summary_tag: str) -> str:
+    return f"mem/{scope_id}/summaries/{summary_tag}/"
+
+
+def _summary_doc_id(scope_id: str, summary_tag: str, ts: str) -> str:
+    """
+    Build a doc_id for a summary. We assume `ts` is an ISO-ish string
+    (e.g. from now_iso()) and rely on lexicographic ordering.
+    """
+    return f"{_summary_prefix(scope_id, summary_tag)}{ts}"

aethergraph/services/metering/eventlog_metering.py

@@ -0,0 +1,470 @@
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+from aethergraph.contracts.services.metering import MeteringService, MeteringStore
+from aethergraph.services.scope.scope import Scope
+
+
+class EventLogMeteringService(MeteringService):
+    """
+    MeteringService implementation backed by a MeteringStore (which itself
+    is backed by an EventLog).
+
+    Behavior notes:
+        - All events are tagged with "meter" for easy filtering
+        - Events are stored with their original metadata for later retrieval
+        - if run_ids is provided in read methods, only events matching those run_ids are returned.
+          This is useful for demo/multi-tenant isolation based on client-tagged runs.
+    """
+
+    def __init__(self, store: MeteringStore):
+        self._store = store
+
+    # ---------- helpers -----------
+
+    @staticmethod
+    def _now() -> datetime:
+        return datetime.now(timezone.utc)
+
+    @staticmethod
+    def _parse_window(window: str) -> datetime:
+        if not window:
+            return datetime.min.replace(tzinfo=timezone.utc)
+
+        unit = window[-1]
+        try:
+            value = int(window[:-1])
+        except ValueError:
+            return datetime.min.replace(tzinfo=timezone.utc)
+
+        if unit == "h":
+            delta = timedelta(hours=value)
+        elif unit == "d":
+            delta = timedelta(days=value)
+        else:
+            delta = timedelta(0)
+
+        return datetime.now(timezone.utc) - delta
+
+    @staticmethod
+    def _dims_from_scope(
+        scope: Scope | None,
+        *,
+        user_id: str | None = None,
+        org_id: str | None = None,
+        run_id: str | None = None,
+        graph_id: str | None = None,
+        client_id: str | None = None,
+        app_id: str | None = None,
+        session_id: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Merge identity/execution dimensions from Scope + explicit overrides.
+
+        - If scope is None, we just return the explicit values.
+        - If scope is present, its metering_dimensions() provide defaults,
+          and explicit args win when provided.
+        """
+        if scope is None:
+            return {
+                "user_id": user_id,
+                "org_id": org_id,
+                "run_id": run_id,
+                "graph_id": graph_id,
+                "client_id": client_id,
+                "app_id": app_id,
+                "session_id": session_id,
+            }
+
+        s = scope.metering_dimensions()
+        return {
+            "user_id": user_id if user_id is not None else s.get("user_id"),
+            "org_id": org_id if org_id is not None else s.get("org_id"),
+            "run_id": run_id if run_id is not None else s.get("run_id"),
+            "graph_id": graph_id if graph_id is not None else s.get("graph_id"),
+            "client_id": client_id if client_id is not None else s.get("client_id"),
+            "app_id": app_id if app_id is not None else s.get("app_id"),
+            "session_id": session_id if session_id is not None else s.get("session_id"),
+        }
+
+    async def _query(
+        self,
+        *,
+        window: str,
+        kinds: list[str],
+        user_id: str | None,
+        org_id: str | None,
+        run_ids: set[str] | None = None,
+    ) -> list[dict[str, Any]]:
+        cutoff = self._parse_window(window)
+
+        # Dev/local: don't restrict by user/org at the store level
+        store_user = None if user_id == "local" or org_id == "local" else user_id
+        store_org = None if user_id == "local" or org_id == "local" else org_id
+
+        rows = await self._store.query(
+            since=cutoff,
+            until=None,
+            kinds=kinds,
+            limit=None,
+            user_id=store_user,
+            org_id=store_org,
+        )
+
+        out: list[dict[str, Any]] = []
+
+        for e in rows:
+            if run_ids is not None:
+                rid = e.get("run_id")
+                if not rid or rid not in run_ids:
+                    continue
+                out.append(e)
+                continue
+
+            # For non-run_ids code paths, we've *already* filtered by user/org in SQL.
+            # Keep the local special case (store_user=None/store_org=None) which
+            # means "no tenant filter" for dev.
+            out.append(e)
+
+        return out
+
+    async def _append(self, event: dict[str, Any]) -> None:
+        # Ensure ts is always set
+        event.setdefault("ts", self._now().isoformat())
+        await self._store.append(event)
+
+    # ---------- record_* methods ----------
+
+    async def record_llm(
+        self,
+        *,
+        scope: Scope | None = None,
+        user_id: str | None = None,
+        org_id: str | None = None,
+        run_id: str | None = None,
+        graph_id: str | None = None,
+        client_id: str | None = None,
+        app_id: str | None = None,
+        session_id: str | None = None,
+        model: str,
+        provider: str,
+        prompt_tokens: int,
+        completion_tokens: int,
+        latency_ms: int | None = None,
+    ) -> None:
+        dims = self._dims_from_scope(
+            scope,
+            user_id=user_id,
+            org_id=org_id,
+            run_id=run_id,
+            graph_id=graph_id,
+            client_id=client_id,
+            app_id=app_id,
+            session_id=session_id,
+        )
+        await self._append(
+            {
+                "kind": "meter.llm",
+                "user_id": dims["user_id"],
+                "org_id": dims["org_id"],
+                "client_id": dims["client_id"],
+                "app_id": dims["app_id"],
+                "session_id": dims["session_id"],
+                "run_id": dims["run_id"],
+                "graph_id": dims["graph_id"],
+                "model": model,
+                "provider": provider,
+                "prompt_tokens": int(prompt_tokens),
+                "completion_tokens": int(completion_tokens),
+                "latency_ms": int(latency_ms) if latency_ms is not None else None,
+                "tags": ["meter.llm"],
+            }
+        )
+
+    async def record_run(
+        self,
+        *,
+        scope: Scope | None = None,
+        user_id: str | None = None,
+        org_id: str | None = None,
+        run_id: str | None = None,
+        graph_id: str | None = None,
+        client_id: str | None = None,
+        app_id: str | None = None,
+        session_id: str | None = None,
+        status: str | None = None,
+        duration_s: float | None = None,
+    ) -> None:
+        dims = self._dims_from_scope(
+            scope,
+            user_id=user_id,
+            org_id=org_id,
+            run_id=run_id,
+            graph_id=graph_id,
+            client_id=client_id,
+            app_id=app_id,
+            session_id=session_id,
+        )
+
+        await self._append(
+            {
+                "kind": "meter.run",
+                "user_id": dims["user_id"],
+                "org_id": dims["org_id"],
+                "client_id": dims["client_id"],
+                "app_id": dims["app_id"],
+                "session_id": dims["session_id"],
+                "run_id": dims["run_id"],
+                "graph_id": dims["graph_id"],
+                "status": status,
+                "duration_s": float(duration_s) if duration_s is not None else None,
+                "tags": ["meter.run"],
+            }
+        )
+
+    async def record_artifact(
+        self,
+        *,
+        scope: Scope | None = None,
+        user_id: str | None = None,
+        org_id: str | None = None,
+        run_id: str | None = None,
+        graph_id: str | None = None,
+        client_id: str | None = None,
+        app_id: str | None = None,
+        session_id: str | None = None,
+        kind: str,
+        bytes: int,
+        pinned: bool = False,
+    ) -> None:
+        dims = self._dims_from_scope(
+            scope,
+            user_id=user_id,
+            org_id=org_id,
+            run_id=run_id,
+            graph_id=graph_id,
+            client_id=client_id,
+            app_id=app_id,
+            session_id=session_id,
+        )
+        await self._append(
+            {
+                "kind": "meter.artifact",
+                "user_id": dims["user_id"],
+                "org_id": dims["org_id"],
+                "client_id": dims["client_id"],
+                "app_id": dims["app_id"],
+                "session_id": dims["session_id"],
+                "run_id": dims["run_id"],
+                "graph_id": dims["graph_id"],
+                "artifact_kind": kind,
+                "bytes": int(bytes),
+                "pinned": bool(pinned),
+                "tags": ["meter.artifact"],
+            }
+        )
+
+    async def record_event(
+        self,
+        *,
+        scope: Scope | None = None,
+        user_id: str | None = None,
+        org_id: str | None = None,
+        run_id: str | None = None,
+        client_id: str | None = None,
+        app_id: str | None = None,
+        session_id: str | None = None,
+        scope_id: str | None = None,
+        kind: str,
+    ) -> None:
+        dims = self._dims_from_scope(
+            scope,
+            user_id=user_id,
+            org_id=org_id,
+            run_id=run_id,
+            graph_id=None,
+            client_id=client_id,
+            app_id=app_id,
+            session_id=session_id,
+        )
+
+        await self._append(
+            {
+                "kind": "meter.event",
+                "user_id": dims["user_id"],
+                "org_id": dims["org_id"],
+                "client_id": dims["client_id"],
+                "app_id": dims["app_id"],
+                "session_id": dims["session_id"],
+                "run_id": dims["run_id"],
+                "event_kind": kind,
+                "scope_id": scope_id,
+                "tags": ["meter.event"],
+            }
+        )
+
+    # ---------- read methods (unchanged for now) ----------
+
+    async def get_overview(
+        self,
+        *,
+        user_id: str | None = None,
+        org_id: str | None = None,
+        window: str = "24h",
+        run_ids: set[str] | None = None,
+    ) -> dict[str, int]:
+        llm = await self._query(
+            window=window,
+            kinds=["meter.llm"],
+            user_id=user_id,
+            org_id=org_id,
+            run_ids=run_ids,
+        )
+
+        runs = await self._query(
+            window=window,
+            kinds=["meter.run"],
+            user_id=user_id,
+            org_id=org_id,
+            run_ids=run_ids,
+        )
+        artifacts = await self._query(
+            window=window,
+            kinds=["meter.artifact"],
+            user_id=user_id,
+            org_id=org_id,
+            run_ids=run_ids,
+        )
+        events = await self._query(
+            window=window,
+            kinds=["meter.event"],
+            user_id=user_id,
+            org_id=org_id,
+            run_ids=run_ids,
+        )
+
+        return {
+            "llm_calls": len(llm),
+            "llm_prompt_tokens": sum(e.get("prompt_tokens", 0) for e in llm),
+            "llm_completion_tokens": sum(e.get("completion_tokens", 0) for e in llm),
+            "runs": len(runs),
+            "runs_succeeded": sum(1 for e in runs if e.get("status") == "succeeded"),
+            "runs_failed": sum(1 for e in runs if e.get("status") == "failed"),
+            "artifacts": len(artifacts),
+            "artifact_bytes": sum(e.get("bytes", 0) for e in artifacts),
+            "events": len(events),
+        }
+
+    async def get_llm_stats(
+        self,
+        *,
+        user_id: str | None = None,
+        org_id: str | None = None,
+        window: str = "24h",
+        run_ids: set[str] | None = None,
+    ) -> dict[str, dict[str, int]]:
+        rows = await self._query(
+            window=window,
+            kinds=["meter.llm"],
+            user_id=user_id,
+            org_id=org_id,
+            run_ids=run_ids,
+        )
+        stats: dict[str, dict[str, int]] = {}
+        for e in rows:
+            model = e.get("model", "unknown")
+            s = stats.setdefault(model, {"calls": 0, "prompt_tokens": 0, "completion_tokens": 0})
+            s["calls"] += 1
+            s["prompt_tokens"] += int(e.get("prompt_tokens", 0))
+            s["completion_tokens"] += int(e.get("completion_tokens", 0))
+        return stats
+
+    async def get_graph_stats(
+        self,
+        *,
+        user_id: str | None = None,
+        org_id: str | None = None,
+        window: str = "24h",
+        run_ids: set[str] | None = None,
+    ) -> dict[str, dict[str, int]]:
+        rows = await self._query(
+            window=window,
+            kinds=["meter.run"],
+            user_id=user_id,
+            org_id=org_id,
+            run_ids=run_ids,
+        )
+        stats: dict[str, dict[str, int]] = {}
+        for e in rows:
+            graph_id = e.get("graph_id") or "unknown"
+            s = stats.setdefault(
+                graph_id, {"runs": 0, "succeeded": 0, "failed": 0, "total_duration_s": 0}
+            )
+            s["runs"] += 1
+            if e.get("status") == "succeeded":
+                s["succeeded"] += 1
+            if e.get("status") == "failed":
+                s["failed"] += 1
+            s["total_duration_s"] += float(e.get("duration_s", 0.0))
+        return stats
+
+    async def get_artifact_stats(
+        self,
+        *,
+        user_id: str | None = None,
+        org_id: str | None = None,
+        window: str = "24h",
+        run_ids: set[str] | None = None,
+    ) -> dict[str, dict[str, int]]:
+        rows = await self._query(
+            window=window,
+            kinds=["meter.artifact"],
+            user_id=user_id,
+            org_id=org_id,
+            run_ids=run_ids,
+        )
+        stats: dict[str, dict[str, int]] = {}
+        for e in rows:
+            ak = e.get("artifact_kind") or "unknown"
+            s = stats.setdefault(
+                ak,
+                {"count": 0, "bytes": 0, "pinned_count": 0, "pinned_bytes": 0},
+            )
+            b = int(e.get("bytes") or 0)
+            pinned = bool(e.get("pinned") or False)
+
+            s["count"] += 1
+            s["bytes"] += b
+            if pinned:
+                s["pinned_count"] += 1
+                s["pinned_bytes"] += b
+        return stats
+
+    async def get_memory_stats(
+        self,
+        *,
+        scope_id: str | None = None,
+        user_id: str | None = None,
+        org_id: str | None = None,
+        window: str = "24h",
+        run_ids: set[str] | None = None,
+    ) -> dict[str, dict[str, int]]:
+        rows = await self._query(
+            window=window,
+            kinds=["meter.event"],
+            user_id=user_id,
+            org_id=org_id,
+            run_ids=run_ids,
+        )
+        stats: dict[str, dict[str, int]] = {}
+        for e in rows:
+            if scope_id is not None and e.get("scope_id") != scope_id:
+                continue
+
+            ek = e.get("event_kind", "")
+            if not ek.startswith("memory."):
+                continue
+
+            s = stats.setdefault(ek, {"count": 0})
+            s["count"] += 1
+        return stats

aethergraph/services/metering/noop.py

@@ -1,4 +1,25 @@
-# services/metering/noop.py
-class NoopMetering:
-    async def incr(self, metric: str, value: float = 1.0, **tags):
-        return None
+from aethergraph.contracts.services.metering import MeteringService
+
+
+class NoopMeteringService(MeteringService):
+    async def record_llm(self, **kwargs):
+        print("NoopMeteringService.record_llm called")
+
+    async def record_run(self, **kwargs): ...
+    async def record_artifact(self, **kwargs): ...
+    async def record_event(self, **kwargs): ...
+
+    async def get_overview(self, **kwargs) -> dict[str, int]:
+        return {}
+
+    async def get_llm_stats(self, **kwargs) -> dict[str, dict[str, int]]:
+        return {}
+
+    async def get_graph_stats(self, **kwargs) -> dict[str, dict[str, int]]:
+        return {}
+
+    async def get_artifact_stats(self, **kwargs) -> dict[str, dict[str, int]]:
+        return {}
+
+    async def get_memory_stats(self, **kwargs) -> dict[str, dict[str, int]]:
+        return {}