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

aethergraph/plugins/channel/adapters/webui.py

@@ -1,134 +1,134 @@
-# src/aethergraph/plugins/channel/adapters/webui.py
 from __future__ import annotations
 
-from collections import deque
-from dataclasses import asdict, is_dataclass
-import logging
+from dataclasses import dataclass
+from datetime import datetime, timezone
 from typing import Any
+import uuid
 
-from aethergraph.contracts.services.channel import ChannelAdapter, OutEvent
+from aethergraph.contracts.services.channel import Button, ChannelAdapter, OutEvent
+from aethergraph.contracts.storage.event_log import EventLog
 from aethergraph.services.continuations.continuation import Correlator
 
 
-class WebSessionHub:
-    def __init__(self, backlog_size: int = 100):
-        self._conns: dict[str, set] = {}
-        self._backlog: dict[str, deque[dict]] = {}
-        self._backlog_size = backlog_size
-
-    async def attach(self, session_id: str, sender):
-        self._conns.setdefault(session_id, set()).add(sender)
-        # flush backlog to this new connection
-        for payload in list(self._backlog.get(session_id, [])):
-            try:
-                await sender(payload)
-            except Exception:
-                logger = logging.getLogger("aethergraph.plugins.channel.adapters.webui")
-                logger.warning(f"Failed to flush backlog payload to session {session_id}")
-
-    async def detach(self, session_id: str, sender):
-        s = self._conns.get(session_id)
-        if s and sender in s:
-            s.remove(sender)
-            if not s:
-                self._conns.pop(session_id, None)
-
-    async def emit(self, session_id: str, payload: dict):
-        conns = list(self._conns.get(session_id, []))
-        if conns:
-            for send in conns:
-                try:
-                    await send(payload)
-                except Exception:
-                    await self.detach(session_id, send)
-            return
-
-        # no live connections → store to backlog
-        q = self._backlog.setdefault(session_id, deque(maxlen=self._backlog_size))
-        q.append(payload)
-
-
-def _serialize_event(event: OutEvent) -> dict:
-    """Dataclass → dict; normalize buttons; strip file bytes; drop None."""
-    if is_dataclass(event):
-        payload = asdict(event)
-    else:
-        # be lenient if a pydantic-like instance sneaks in
-        payload = (
-            (getattr(event, "model_dump", None) and event.model_dump())
-            or (getattr(event, "dict", None) and event.dict())
-            or dict(event)
-        )
-
-    # normalize buttons dict -> list
-    btns = payload.get("buttons")
-    if isinstance(btns, dict):
-        payload["buttons"] = list(btns.values())
-
-    # drop binary bytes from file
-    f = payload.get("file")
-    if isinstance(f, dict) and "bytes" in f:
-        f = f.copy()
-        f.pop("bytes", None)
-        payload["file"] = f
-
-    # clean None
-    return {k: v for k, v in payload.items() if v is not None}
-
-
-class WebChannelAdapter(ChannelAdapter):
+@dataclass
+class UIChannelEvent:
+    id: str
+    run_id: str
+    channel_key: str
+    type: str  # original OutEvent.type, e.g. "agent.message"
+    text: str | None
+    buttons: list[dict[str, Any]]
+    file: dict[str, Any] | None
+    meta: dict[str, Any]
+    ts: float
+
+
+class WebUIChannelAdapter(ChannelAdapter):
     """
-    Channel key: 'web:session/{session_id}'
-    Mirrors Slack adapter semantics for:
-      - correlators
-      - stream/progress upserts via upsert_key
-      - buttons/image/file payload shapes
+    Channel adapter for the AetherGraph web UI.
+
+    - channel_key format (d0): "ui:run/<run_id>"
+    - Writes normalized UI events into EventLog with scope_id=f"run-ui:{run_id}"
     """
 
-    capabilities: set[str] = {"text", "buttons", "image", "file", "edit", "stream"}
+    capabilities: set[str] = {"text", "buttons", "file", "stream", "edit"}
 
-    def __init__(self, hub: WebSessionHub):
-        self.hub = hub
-        self._first_msg_by_key: dict[
-            tuple[str, str], str
-        ] = {}  # (channel, upsert_key) -> synthetic message id
-        self._seq_by_chan: dict[str, int] = {}
+    def __init__(self, event_log: EventLog):
+        self.event_log = event_log
 
-    @staticmethod
-    def _parse(channel_key: str) -> dict:
-        # "web:session/{id}" -> {"session": "..."}
-        parts = channel_key.split(":", 1)[1]  # session/{id}
-        k, v = parts.split("/", 1)
-        return {k: v}
+    def _extract_target(self, channel_key: str) -> tuple[str, str]:
+        """
+        Parse "ui:run/<run_id>" or "ui:session/<session_id>".
 
-    def _next_seq(self, ch: str) -> str:
-        n = self._seq_by_chan.get(ch, 0) + 1
-        self._seq_by_chan[ch] = n
-        return str(n)
+        Returns (scope_kind, id), where scope_kind in {"run", "session"}.
+        """
+        try:
+            scheme, rest = channel_key.split(":", 1)
+        except ValueError as exc:
+            raise ValueError(f"Invalid UI channel key: {channel_key!r}") from exc
 
-    async def peek_thread(self, channel_key: str) -> str | None:
-        # no threads in web adapter
-        return None
+        if scheme != "ui":
+            raise ValueError(f"Invalid UI channel key scheme: {scheme!r}")
 
-    async def send(self, event: OutEvent) -> dict | None:
-        meta = self._parse(event.channel)
-        session_id = meta["session"]
+        if rest.startswith("run/"):
+            return "run", rest.split("/", 1)[1]
+        if rest.startswith("session/"):
+            return "session", rest.split("/", 1)[1]
+
+        # fallback: treat as run id
+        return "run", rest
 
-        # upsert bookkeeping like Slack: ensure a stable logical message per upsert_key
-        if event.upsert_key:
-            key = (event.channel, event.upsert_key)
-            if key not in self._first_msg_by_key:
-                self._first_msg_by_key[key] = self._next_seq(event.channel)
+    def _button_to_dict(self, b: Button | Any) -> dict[str, Any]:
+        # Be defensive: Button is a dataclass, but Slack adapter also handles light-weight objects
+        return {
+            "label": getattr(b, "label", None),
+            "value": getattr(b, "value", None),
+            "style": getattr(b, "style", None),
+            "url": getattr(b, "url", None),
+        }
+
+    async def send(self, event: OutEvent) -> dict | None:
+        scope_kind, target_id = self._extract_target(event.channel)
+
+        raw_buttons = getattr(event, "buttons", None) or []
+        buttons = [self._button_to_dict(b) for b in raw_buttons]
+        file_info = getattr(event, "file", None) or None
+
+        # richer event support
+        files = getattr(event, "files", None) or None
+        rich = getattr(event, "rich", None) or None
+        upsert_key = getattr(event, "upsert_key", None)
+
+        meta = event.meta or {}
+        # Agent_id
+        # prefer cononical agent_id; otherwise fall back to legacy field
+        agent_id = meta.get("agent_id") or meta.get("agent")
+        if agent_id:
+            meta["agent_id"] = agent_id
+
+        # Prefer explicit session_id / run_id from meta when present
+        session_id = meta.get("session_id")
+        run_id = meta.get("run_id")
+
+        if scope_kind == "session":
+            scope_id = session_id or target_id
+            kind = "session_chat"
+        else:  # "run"
+            scope_id = run_id or target_id
+            kind = "run_channel"
+
+        row = {
+            "id": str(uuid.uuid4()),
+            "ts": datetime.now(timezone.utc).timestamp(),
+            "scope_id": scope_id,
+            "kind": kind,
+            "payload": {
+                "type": event.type,
+                "text": event.text,
+                "buttons": buttons,
+                "file": file_info,
+                "files": files,
+                "rich": rich,
+                "upsert_key": upsert_key,
+                "meta": meta,
+                # optional convenience copy:
+                "agent_id": meta.get("agent_id"),
+            },
+        }
+        await self.event_log.append(row)
 
-        payload: dict[str, Any] = _serialize_event(event)
-        await self.hub.emit(session_id, payload)
+        ## In the future, if an EventHub is available, broadcast to WebSocket subscribers.
+        ## self.event_log is always the source of truth.
+        # if self.event_hub is not None:
+        #     await self.event_hub.broadcast(row)
 
-        # return correlator so ChannelSession can bind (consistent with Slack)
+        # Correlator remains run-based for now (session may not map 1-1)
         return {
+            "run_id": run_id or target_id,
             "correlator": Correlator(
-                scheme="web",
+                scheme="ui",
                 channel=event.channel,
-                thread=None,
-                message=self._next_seq(event.channel),
-            )
+                thread="",
+                message=None,
+            ),
         }