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

aethergraph/services/artifacts/facade.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import asyncio
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
-from datetime import datetime
+from datetime import datetime, timezone
 import json
 from pathlib import Path
 from typing import Any, Literal
@@ -12,12 +12,15 @@ from urllib.parse import urlparse
 
 from aethergraph.contracts.services.artifacts import Artifact, AsyncArtifactStore
 from aethergraph.contracts.storage.artifact_index import AsyncArtifactIndex
+from aethergraph.contracts.storage.search_backend import ScoredItem
 from aethergraph.core.runtime.runtime_metering import current_metering
 from aethergraph.core.runtime.runtime_services import current_services
 from aethergraph.services.artifacts.paths import _from_uri_or_path
+from aethergraph.services.artifacts.types import ArtifactContent, ArtifactSearchResult, ArtifactView
+from aethergraph.services.artifacts.utils import _infer_content_mode
+from aethergraph.services.indices.scoped_indices import ScopedIndices
 from aethergraph.services.scope.scope import Scope
-
-ArtifactView = Literal["node", "graph", "run", "all"]
+from aethergraph.storage.vector_index.utils import build_index_meta_from_scope
 
 
 class ArtifactFacade:
@@ -37,8 +40,9 @@ class ArtifactFacade:
         node_id: str,
         tool_name: str,
         tool_version: str,
-        store: AsyncArtifactStore,
-        index: AsyncArtifactIndex,
+        art_store: AsyncArtifactStore,
+        art_index: AsyncArtifactIndex,
+        scoped_indices: ScopedIndices | None = None,
         scope: Scope | None = None,
     ) -> None:
         self.run_id = run_id
@@ -46,8 +50,9 @@ class ArtifactFacade:
         self.node_id = node_id
         self.tool_name = tool_name
         self.tool_version = tool_version
-        self.store = store
-        self.index = index
+        self.store = art_store
+        self.index = art_index
+        self.scoped_indices = scoped_indices
 
         # set scope -- this should be done outside in NodeContext and passed in, but here is a fallback
         self.scope = scope
@@ -124,11 +129,94 @@ class ArtifactFacade:
             a.session_id = a.session_id or dims.get("session_id")
             # run_id / graph_id / node_id are already set
 
+        # 1.1) Normalize timestamp: ensure a.created_at is a UTC datetime
+        created_dt: datetime
+        if isinstance(a.created_at, datetime):
+            if a.created_at.tzinfo is None:
+                created_dt = a.created_at.replace(tzinfo=timezone.utc)
+            else:
+                created_dt = a.created_at.astimezone(timezone.utc)
+        elif isinstance(a.created_at, str):
+            # Best-effort parse; if it fails, fall back to "now"
+            try:
+                # Accept either Z-suffixed or offset ISO
+                if a.created_at.endswith("Z"):
+                    created_dt = datetime.fromisoformat(a.created_at.replace("Z", "+00:00"))
+                else:
+                    created_dt = datetime.fromisoformat(a.created_at)
+                if created_dt.tzinfo is None:
+                    created_dt = created_dt.replace(tzinfo=timezone.utc)
+                else:
+                    created_dt = created_dt.astimezone(timezone.utc)
+            except Exception:
+                created_dt = datetime.now(timezone.utc)
+        else:
+            # No timestamp provided → use now
+            created_dt = datetime.now(timezone.utc)
+
+        # Persist normalized timestamp back onto the artifact
+        a.created_at = created_dt
+        # Canonical forms:
+        ts_iso = created_dt.replace(microsecond=0).isoformat().replace("+00:00", "Z")
+        created_at_ts = created_dt.timestamp()
+
         # 2) Record in index + occurrence log
         await self.index.upsert(a)
         await self.index.record_occurrence(a)
         self.last_artifact = a
 
+        # 2.1) Wire artifact text into ScopedIndices for searchability
+        if self.scoped_indices is not None and self.scoped_indices.backend is not None:
+            try:
+                # Build a simple text blob from labels, metrics, and kind
+                # Build text blob
+                parts: list[str] = []
+                if a.kind:
+                    parts.append(str(a.kind))
+                if a.labels:
+                    parts.append("; ".join(f"{k}: {v}" for k, v in a.labels.items()))
+                if a.metrics:
+                    parts.append("; ".join(f"{k}: {v}" for k, v in a.metrics.items()))
+                text = " ".join(parts).strip()
+
+                extra_meta: dict[str, Any] = {
+                    "run_id": a.run_id,
+                    "graph_id": a.graph_id,
+                    "node_id": a.node_id,
+                    "tool_name": a.tool_name,
+                    "tool_version": a.tool_version,
+                    "pinned": a.pinned,
+                }
+
+                # Add artifact kind as explicit metadata field
+                if a.kind:
+                    extra_meta["artifact_kind"] = a.kind
+
+                # Flatten labels last so they can override if needed
+                if a.labels:
+                    extra_meta.update(a.labels)
+
+                meta = build_index_meta_from_scope(
+                    kind="artifact",
+                    source="artifact_index",
+                    ts=ts_iso,  # human-readable ISO
+                    created_at_ts=created_at_ts,  # numeric timestamp
+                    extra=extra_meta,
+                )
+
+                await self.scoped_indices.upsert(
+                    corpus="artifact",
+                    item_id=a.artifact_id,
+                    text=text,
+                    metadata=meta,
+                )
+            except Exception:
+                import logging
+
+                logging.getLogger("aethergraph.indices").exception(
+                    "scoped_indices_artifact_upsert_failed"
+                )
+
         # 3) Metering hook for artifact writes
         try:
             meter = current_metering()
@@ -158,18 +246,6 @@ class ArtifactFacade:
         except Exception:
             return  # outside runtime context, nothing to do
 
-        # Normalize timestamp
-        ts: datetime | None
-        if isinstance(a.created_at, datetime):
-            ts = a.created_at
-        elif isinstance(a.created_at, str):
-            try:
-                ts = datetime.fromisoformat(a.created_at)
-            except Exception:
-                ts = None
-        else:
-            ts = None
-
         # Update run metadata
         run_store = getattr(services, "run_store", None)
         if run_store is not None and a.run_id:
@@ -178,7 +254,7 @@ class ArtifactFacade:
                 await record_artifact(
                     a.run_id,
                     artifact_id=a.artifact_id,
-                    created_at=ts,
+                    created_at=created_dt,
                 )
 
         # Update session metadata
@@ -189,7 +265,7 @@ class ArtifactFacade:
             if callable(sess_record_artifact):
                 await sess_record_artifact(
                     session_id,
-                    created_at=ts,
+                    created_at=created_dt,
                 )
 
     # ---------- core staging/ingest ----------
@@ -823,6 +899,53 @@ class ArtifactFacade:
         text = await self.load_text_by_id(artifact_id, encoding=encoding, errors=errors)
         return json.loads(text)
 
+    async def load_content(
+        self,
+        artifact_id: str,
+        *,
+        encoding: str = "utf-8",
+        errors: str = "strict",
+        max_bytes: int | None = None,
+    ) -> ArtifactContent:
+        """
+        Docstring for load_content
+
+        :param self: Description
+        :param artifact_id: Description
+        :type artifact_id: str
+        :param encoding: Description
+        :type encoding: str
+        :param errors: Description
+        :type errors: str
+        :param max_bytes: Description
+        :type max_bytes: int | None
+        :return: Description
+        :rtype: ArtifactContent
+        """
+        art = await self.get_by_id(artifact_id=artifact_id)
+        if art is None:
+            raise FileNotFoundError(f"Artifact {artifact_id} not found")
+
+        mode = _infer_content_mode(art)
+
+        def maybe_truncate(data: bytes) -> bytes:
+            if max_bytes is not None and len(data) > max_bytes:
+                return data[:max_bytes]
+            return data
+
+        if mode == "json":
+            data = await self.load_json_by_id(artifact_id, encoding=encoding, errors=errors)
+            return ArtifactContent(artifact=art, mode=mode, json=data)
+
+        if mode == "text":
+            text = await self.load_text_by_id(artifact_id, encoding=encoding, errors=errors)
+            return ArtifactContent(artifact=art, mode=mode, text=text)
+
+        # raw bytes
+        raw = await self.load_bytes_by_id(artifact_id)
+        raw = maybe_truncate(raw)
+        return ArtifactContent(artifact=art, mode="bytes", data=raw)
+
     async def as_local_file_by_id(
         self,
         artifact_id: str,
@@ -1279,6 +1402,19 @@ class ArtifactFacade:
         """
         await self.index.pin(artifact_id, pinned=pinned)
 
+    # ---------- search result hydration ----------
+    async def fetch_artifacts_for_search_results(
+        self,
+        scored_items: list[ScoredItem],
+        corpus: str = "artifact",
+    ) -> list[ArtifactSearchResult]:
+        artifact_items = [it for it in scored_items if it.corpus == corpus]
+        results: list[ArtifactSearchResult] = []
+        for it in artifact_items:
+            art = await self.get_by_id(it.item_id)
+            results.append(ArtifactSearchResult(item=it, artifact=art))
+        return results
+
     # ---------- internal helpers ----------
     async def _record_simple(self, a: Artifact) -> None:
         """Record artifact in index and occurrence log."""

aethergraph/services/artifacts/types.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+from typing import Any, Literal, NamedTuple
+
+from aethergraph.contracts.services.artifacts import Artifact
+from aethergraph.contracts.storage.search_backend import ScoredItem
+
+ContentMode = Literal["json", "text", "bytes"]
+
+ArtifactView = Literal["node", "graph", "run", "all"]
+
+
+class ArtifactSearchResult(NamedTuple):
+    item: ScoredItem  # raw search result (score, metadata, etc.)
+    artifact: Artifact | None  # hydrated Artifact, or None if missing
+
+    @property
+    def id(self) -> str:
+        return self.item.item_id
+
+    @property
+    def score(self) -> float:
+        return self.item.score
+
+    @property
+    def meta(self) -> dict[str, Any]:
+        return self.item.metadata
+
+
+@dataclass
+class ArtifactContent:
+    artifact: Artifact
+    mode: ContentMode  # "json", "text", or "bytes"
+    text: str | None = None
+    json: Any | None = None
+    data: bytes | None = None

aethergraph/services/artifacts/utils.py

@@ -6,6 +6,9 @@ import json
 import os
 from pathlib import Path
 
+from aethergraph.contracts.services.artifacts import Artifact
+from aethergraph.services.artifacts.types import ContentMode
+
 
 def now_iso() -> str:
     return datetime.now(timezone.utc).isoformat()
@@ -122,3 +125,42 @@ def _maybe_cleanup_tmp_parent(tmp_root: str, path: str):
             parent = os.path.dirname(parent)
     except Exception:
         pass
+
+
+def _infer_content_mode(artifact: Artifact) -> ContentMode:
+    """
+    Decide how to load this artifact: as JSON, text, or raw bytes.
+
+    Priority:
+    1) artifact.kind
+    2) filename extension
+    3) default to bytes
+    """
+    k = (getattr(artifact, "kind", None) or "").lower()
+
+    # 1) Use explicit kind when we know what to do
+    if k == "json":
+        return "json"
+    if k in {"text", "log", "note"}:
+        return "text"
+    if k in {"image", "plot", "figure"}:
+        return "bytes"  # bytes → caller decides what to do with an image
+
+    # 2) Fall back to filename extension
+    filename = None
+    if getattr(artifact, "labels", None):
+        filename = artifact.labels.get("filename")
+    if not filename:
+        filename = getattr(artifact, "name", None)
+
+    if filename:
+        ext = Path(filename).suffix.lower()
+        if ext == ".json":
+            return "json"
+        if ext in {".txt", ".md", ".log", ".csv"}:
+            return "text"
+        if ext in {".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp"}:
+            return "bytes"
+
+    # 3) Unknown → safest is bytes
+    return "bytes"

aethergraph/services/channel/channel_bus.py

@@ -47,7 +47,9 @@ class ChannelBus:
     def register_alias(self, alias: str, target: str) -> None:
         """Register or overwrite a human-friendly alias -> canonical key."""
         if self._prefix(target) not in self.adapters:
-            raise RuntimeError(f"Cannot alias to unknown channel prefix: {self._prefix(target)}")
+            raise RuntimeError(
+                f"Cannot alias to unknown channel prefix: {self._prefix(target)}. Please check if you have enabled the required channel service in .env and registered the adapter."
+            )
 
         self.channel_aliases[alias] = target
 

aethergraph/services/channel/event_hub copy.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import asyncio
+from collections import defaultdict
+from collections.abc import AsyncIterator
+from typing import Any
+
+
+class EventHub:
+    """
+    In-memory pub/sub for UI events.
+
+    - Keys by scope_id (session_id or run_id).
+    - Optionally filters by kind (e.g. "session_chat", "run_channel").
+    """
+
+    def __init__(self) -> None:
+        self._subscribers: dict[str, set[asyncio.Queue]] = defaultdict(set)
+        self._lock = asyncio.Lock()
+
+    async def subscribe(self, scope_id: str) -> AsyncIterator[dict[str, Any]]:
+        """
+        Async generator: yields raw EventLog-like rows with keys:
+        { "id", "ts", "scope_id", "kind", "payload": {...} }
+        """
+        q: asyncio.Queue = asyncio.Queue()
+        async with self._lock:
+            self._subscribers[scope_id].add(q)
+
+        try:
+            while True:
+                row = await q.get()
+                yield row
+        finally:
+            async with self._lock:
+                self._subscribers[scope_id].discard(q)
+                if not self._subscribers[scope_id]:
+                    self._subscribers.pop(scope_id, None)
+
+    async def broadcast(self, row: dict[str, Any]) -> None:
+        scope_id = row.get("scope_id")
+        if not scope_id:
+            return
+        async with self._lock:
+            subs = list(self._subscribers.get(scope_id, []))
+        for q in subs:
+            # Best-effort; if queue is full we drop rather than block worker
+            try:
+                q.put_nowait(row)
+            except asyncio.QueueFull:
+                # log if you want
+                import logging
+
+                logger = logging.getLogger(__name__)
+                logger.warning(f"EventHub queue full for scope_id={scope_id}, dropping event")

aethergraph/services/channel/event_hub.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import asyncio
+from collections import defaultdict
+from collections.abc import AsyncIterator
+from contextlib import suppress
+from typing import Any
+
+_SENTINEL = object()
+
+
+class EventHub:
+    """
+    In-memory pub/sub for UI events.
+    Keys by (scope_id, kind).
+    """
+
+    def __init__(self) -> None:
+        self._subscribers: dict[tuple[str, str], set[asyncio.Queue]] = defaultdict(set)
+        self._lock = asyncio.Lock()
+        self._closed = False
+
+    async def subscribe(
+        self,
+        *,
+        scope_id: str,
+        kind: str,
+        max_queue: int = 256,
+    ) -> AsyncIterator[dict[str, Any]]:
+        """
+        Async generator that yields rows for (scope_id, kind).
+        """
+        q: asyncio.Queue = asyncio.Queue(maxsize=max_queue)
+
+        async with self._lock:
+            if self._closed:
+                return
+            self._subscribers[(scope_id, kind)].add(q)
+
+        try:
+            while True:
+                item = await q.get()
+                if item is _SENTINEL:
+                    return
+                yield item
+        finally:
+            async with self._lock:
+                self._subscribers[(scope_id, kind)].discard(q)
+                if not self._subscribers[(scope_id, kind)]:
+                    self._subscribers.pop((scope_id, kind), None)
+
+    async def broadcast(self, row: dict[str, Any]) -> None:
+        scope_id = row.get("scope_id")
+        kind = row.get("kind")
+        if not scope_id or not kind:
+            return
+
+        async with self._lock:
+            subs = list(self._subscribers.get((scope_id, kind), []))
+
+        for q in subs:
+            try:
+                q.put_nowait(row)
+            except asyncio.QueueFull:
+                # Drop instead of blocking producer
+                continue
+
+    async def close(self) -> None:
+        """
+        Wake and detach all subscribers (useful on shutdown/reload).
+        """
+        async with self._lock:
+            self._closed = True
+            all_queues = []
+            for qs in self._subscribers.values():
+                all_queues.extend(list(qs))
+            self._subscribers.clear()
+
+        for q in all_queues:
+            with suppress(Exception):
+                q.put_nowait(_SENTINEL)

aethergraph/services/channel/factory.py

@@ -12,10 +12,11 @@ from aethergraph.plugins.channel.adapters.slack import SlackChannelAdapter
 from aethergraph.plugins.channel.adapters.telegram import TelegramChannelAdapter
 from aethergraph.plugins.channel.adapters.webhook import WebhookChannelAdapter
 from aethergraph.services.channel.channel_bus import ChannelBus
+from aethergraph.services.channel.event_hub import EventHub
 
 
 def make_channel_adapters_from_env(
-    cfg: AppSettings, event_log: EventLog | None = None
+    cfg: AppSettings, event_log: EventLog | None = None, event_hub: EventHub | None = None
 ) -> dict[str, Any]:
     # Always include console adapter
     adapters = {"console": ConsoleChannelAdapter()}
@@ -40,7 +41,7 @@ def make_channel_adapters_from_env(
 
     if event_log is None:
         raise ValueError("event_log must be provided to create WebUIChannelAdapter")
-    adapters["ui"] = WebUIChannelAdapter(event_log=event_log)
+    adapters["ui"] = WebUIChannelAdapter(event_log=event_log, event_hub=event_hub)
     return adapters