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

aethergraph/plugins/channel/utils/slack_utils.py

@@ -6,7 +6,11 @@ import time
 import aiohttp
 from fastapi import HTTPException, Request
 
-from aethergraph.services.continuations.continuation import Correlator
+from aethergraph.services.channel.ingress import (
+    ChannelIngress,
+    IncomingFile,
+    IncomingMessage,
+)
 
 
 # --- shared utils ---
@@ -19,11 +23,20 @@ async def _download_slack_file(url: str, token: str) -> bytes:
         return await r.read()
 
 
-# async def _download_slack_file(url: str, token: str) -> bytes:
-#     async with aiohttp.ClientSession() as sess:
-#         async with sess.get(url, headers={"Authorization": f"Bearer {token}"}) as r:
-#             r.raise_for_status()
-#             return await r.read()
+def _slack_scheme_and_channel_id(team_id: str | None, channel_id: str | None) -> tuple[str, str]:
+    """
+    Map Slack team/channel to the (scheme, channel_id) pair used by ChannelIngress.
+
+    We keep the existing Slack channel key shape:
+      ch_key = "slack:team/T:chan/C"
+    and split it as:
+      scheme = "slack"
+      channel_id = "team/T:chan/C"
+    """
+    team = team_id or "unknown"
+    chan = channel_id or "unknown"
+    # This matches your existing _channel_key base form.
+    return "slack", f"team/{team}:chan/{chan}"
 
 
 def _verify_sig(request: Request, body: bytes):
@@ -62,7 +75,7 @@ def _channel_key(team_id: str, channel_id: str, thread_ts: str | None) -> str:
 async def _stage_and_save(c, *, data: bytes, file_id: str, name: str, ch_key: str, cont) -> str:
     """Write bytes to tmp path, then save via FileArtifactStore.save_file(...).
     Returns the Artifact.uri (string)."""
-    tmp = c.artifacts.tmp_path(suffix=f"_{file_id}")
+    tmp = await c.artifacts.plan_staging_path(planned_ext=f"_{file_id}")
     with open(tmp, "wb") as f:
         f.write(data)
     run_id = cont.run_id if cont else "ad-hoc"
@@ -88,12 +101,13 @@ async def _stage_and_save(c, *, data: bytes, file_id: str, name: str, ch_key: st
 async def handle_slack_events_common(container, settings, payload: dict) -> dict:
     """
     Common handler for Slack Events API payloads.
-    This is transport-agnostic: can be called from HTTP route or Socket Mode.
+    Now delegates continuation lookup & resume to ChannelIngress.
     """
     SLACK_BOT_TOKEN = (
         settings.slack.bot_token.get_secret_value() if settings.slack.bot_token else ""
     )
     c = container
+    ingress: ChannelIngress = c.channel_ingress  # must exist in your container
 
     ev = payload.get("event") or {}
     ev_type = ev.get("type")
@@ -105,19 +119,13 @@ async def handle_slack_events_common(container, settings, payload: dict) -> dict
         chan = ev.get("channel")
         text = ev.get("text", "") or ""
         files = ev.get("files") or []
-        ch_key = _channel_key(team, chan, None)
 
-        cont = None
-        if thread_ts:
-            # Try precise thread-level match
-            corr = Correlator(scheme="slack", channel=ch_key, thread=thread_ts, message="")
-            cont = await c.cont_store.find_by_correlator(corr=corr)
-        if not cont:
-            # Fallback to channel-root
-            corr2 = Correlator(scheme="slack", channel=ch_key, thread="", message="")
-            cont = await c.cont_store.find_by_correlator(corr=corr2)
-
-        file_refs = []
+        # Full Slack key for labels/metadata
+        ch_key = _channel_key(team, chan, None)  # "slack:team/T:chan/C"
+        scheme, channel_id = _slack_scheme_and_channel_id(team, chan)  # ("slack", "team/T:chan/C")
+
+        # --- Slack-specific file download + artifact save ---
+        file_refs: list[dict] = []
         if files:
             token = SLACK_BOT_TOKEN
             for f in files:
@@ -130,11 +138,17 @@ async def handle_slack_events_common(container, settings, payload: dict) -> dict
                 url_priv = f.get("url_private") or f.get("url_private_download")
 
                 uri = None
-                if url_priv:
+                if url_priv and token:
                     try:
                         data_bytes = await _download_slack_file(url_priv, token)
+                        # use Slack-specific labels via _stage_and_save
                         uri = await _stage_and_save(
-                            c, data=data_bytes, file_id=file_id, name=name, ch_key=ch_key, cont=cont
+                            c,
+                            data=data_bytes,
+                            file_id=file_id,
+                            name=name,
+                            ch_key=ch_key,
+                            cont=None,  # we don't know cont yet; ChannelIngress will find it
                         )
                     except Exception as e:
                         container.logger and container.logger.warning(
@@ -155,19 +169,48 @@ async def handle_slack_events_common(container, settings, payload: dict) -> dict
                     }
                 )
 
-            # append to per-channel inbox (dedupe by id)
-            inbox_key = f"inbox://{ch_key}"
-            await c.kv_hot.list_append_unique(inbox_key, file_refs, id_key="id")
+        # Turn Slack file_refs into IncomingFile so Ingress can do inbox + payload
+        incoming_files: list[IncomingFile] = []
+        for fr in file_refs:
+            incoming_files.append(
+                IncomingFile(
+                    id=fr["id"],
+                    name=fr["name"],
+                    mimetype=fr.get("mimetype"),
+                    size=fr.get("size"),
+                    uri=fr.get("uri"),  # already artifact-backed
+                    url=None,  # no re-download
+                    extra={
+                        "platform": "slack",
+                        "channel_key": fr.get("channel_key"),
+                        "ts": fr.get("ts"),
+                    },
+                )
+            )
 
-        if not cont:
-            return {}
+        meta = {
+            "raw": payload,
+            "channel_key": ch_key,
+        }
+
+        # Let ChannelIngress find the continuation, update inbox, and resume
+        resumed = await ingress.handle(
+            IncomingMessage(
+                scheme=scheme,
+                channel_id=channel_id,
+                thread_id=str(thread_ts or ""),
+                text=text,
+                files=incoming_files or None,
+                meta=meta,
+            )
+        )
 
-        if cont.kind in ("user_files", "user_input_or_files"):
-            await c.resume_router.resume(
-                cont.run_id, cont.node_id, cont.token, {"text": text, "files": file_refs}
+        if container.logger:
+            container.logger.for_run().debug(
+                f"[Slack] inbound message: text={text!r}, files={len(incoming_files)}, resumed={resumed}"
             )
-        else:
-            await c.resume_router.resume(cont.run_id, cont.node_id, cont.token, {"text": text})
+
+        # Nothing special to return to Slack (Events API only cares that we 200)
         return {}
 
     # --- file_shared (out-of-band file) ---
@@ -182,15 +225,9 @@ async def handle_slack_events_common(container, settings, payload: dict) -> dict
         chan = ev.get("channel_id") or (ev.get("channel") or {}).get("id")
         if not (file_id and chan):
             return {}
-        ch_key = _channel_key(team, chan, None)
 
-        cont = None
-        if thread_ts:
-            corr = Correlator(scheme="slack", channel=ch_key, thread=thread_ts, message="")
-            cont = await c.cont_store.find_by_correlator(corr=corr)
-        if not cont:
-            corr2 = Correlator(scheme="slack", channel=ch_key, thread="", message="")
-            cont = await c.cont_store.find_by_correlator(corr=corr2)
+        ch_key = _channel_key(team, chan, None)
+        scheme, channel_id = _slack_scheme_and_channel_id(team, chan)
 
         info = await c.slack.client.files_info(file=file_id)
         f = info.get("file") or {}
@@ -200,39 +237,58 @@ async def handle_slack_events_common(container, settings, payload: dict) -> dict
         url_priv = f.get("url_private") or f.get("url_private_download")
 
         uri = None
-        if url_priv:
+        if url_priv and SLACK_BOT_TOKEN:
             try:
                 data_bytes = await _download_slack_file(url_priv, SLACK_BOT_TOKEN)
                 uri = await _stage_and_save(
-                    c, data=data_bytes, file_id=file_id, name=name, ch_key=ch_key, cont=cont
+                    c,
+                    data=data_bytes,
+                    file_id=file_id,
+                    name=name,
+                    ch_key=ch_key,
+                    cont=None,
                 )
             except Exception as e:
                 container.logger and container.logger.for_run().warning(
                     f"Slack download failed: {e}", exc_info=True
                 )
 
-        fr = {
-            "id": file_id,
-            "name": name,
-            "mimetype": mimetype,
-            "size": size,
-            "uri": uri,
-            "url_private": url_priv,
-            "platform": "slack",
-            "channel_key": ch_key,
-            "ts": ev.get("event_ts"),
-        }
+        # Build IncomingFile with pre-saved uri
+        incoming_file = IncomingFile(
+            id=file_id,
+            name=name,
+            mimetype=mimetype,
+            size=size,
+            uri=uri,  # already artifact-backed, no re-download when uri used in ingress
+            url=None,
+            extra={
+                "platform": "slack",
+                "channel_key": ch_key,
+                "ts": ev.get("event_ts"),
+            },
+        )
+
+        meta = {"raw": payload, "channel_key": ch_key}
 
-        inbox_key = f"inbox://{ch_key}"
-        await c.kv_hot.list_append_unique(inbox_key, [fr], id_key="id")
+        resumed = await ingress.handle(
+            IncomingMessage(
+                scheme=scheme,
+                channel_id=channel_id,
+                thread_id=str(thread_ts or ""),
+                text="",  # no text; just a file drop
+                files=[incoming_file],
+                meta=meta,
+            )
+        )
 
-        if cont and cont.kind in ("user_files", "user_input_or_files"):
-            await c.resume_router.resume(
-                cont.run_id, cont.node_id, cont.token, {"text": "", "files": [fr]}
+        if container.logger:
+            container.logger.for_run().debug(
+                f"[Slack] file_shared: file_id={file_id}, resumed={resumed}"
             )
+
         return {}
 
-    # other events might add later
+    # other events might be added later
     return {}
 
 

aethergraph/plugins/channel/utils/telegram_utils.py

@@ -5,6 +5,11 @@ from typing import Any
 import aiohttp
 from fastapi import APIRouter, HTTPException, Request
 
+from aethergraph.services.channel.ingress import (
+    ChannelIngress,
+    IncomingFile,
+    IncomingMessage,
+)
 from aethergraph.services.continuations.continuation import Correlator
 
 router = APIRouter()
@@ -43,6 +48,23 @@ def _channel_key(chat_id: int, topic_id: int | None) -> str:
     return f"{base}:topic/{int(topic_id)}" if topic_id else base
 
 
+def _tg_scheme_and_channel_id(chat_id: int, topic_id: int | None) -> tuple[str, str]:
+    """
+    Map Telegram chat/topic to (scheme, channel_id) pair for ChannelIngress.
+
+    _channel_key(chat_id, topic_id) builds:
+      "tg:chat/<id>" or "tg:chat/<id>:topic/<topic_id>"
+
+    So we use:
+      scheme    = "tg"
+      channel_id = "chat/<id>" or "chat/<id>:topic/<topic_id>"
+    """
+    base = f"chat/{int(chat_id)}"
+    if topic_id:
+        base = f"{base}:topic/{int(topic_id)}"
+    return "tg", base
+
+
 # ---- helpers ----
 async def _tg_get_file_path(file_id: str, token: str) -> str | None:
     if not token:
@@ -64,10 +86,11 @@ async def _tg_download_file(file_path: str, token: str) -> bytes:
         return await r.read()
 
 
-# -------- NEW: background worker that does the heavy lifting --------
 async def _process_update(container, payload: dict, token: str):
+    ingress: ChannelIngress = container.channel_ingress
+
     try:
-        # Callback queries (inline button presses)
+        # 1) Callback queries (inline buttons) -------------------------
         cq = payload.get("callback_query")
         if cq:
             msg = cq.get("message") or {}
@@ -94,35 +117,37 @@ async def _process_update(container, payload: dict, token: str):
                     choice = str(data_raw)
 
             choice_l = choice.lower()
-            # approved = choice_l.startswith("approve") or choice_l in {"yes","y","ok"} # resolve from choice string
 
-            token = None
+            tok = None
             run_id = None
             node_id = None
 
-            # Resolve alias → token (preferred)
+            # Preferred: resolve alias → token
             if resume_key and hasattr(container.cont_store, "token_from_alias"):
-                token = container.cont_store.token_from_alias(resume_key)
+                tok = container.cont_store.token_from_alias(resume_key)
 
-            if token and hasattr(container.cont_store, "get_by_token"):
-                cont = container.cont_store.get_by_token(token)
+            if tok and hasattr(container.cont_store, "get_by_token"):
+                cont = container.cont_store.get_by_token(tok)
                 if cont:
                     run_id, node_id = cont.run_id, cont.node_id
 
             # Fallback: thread-scoped correlator
-            if not token:
+            if not tok:
                 corr = Correlator(
-                    scheme="tg", channel=ch_key, thread=str(topic_id or ""), message=""
+                    scheme="tg",
+                    channel=ch_key,
+                    thread=str(topic_id or ""),
+                    message="",
                 )
                 cont = await container.cont_store.find_by_correlator(corr=corr)
                 if cont:
-                    run_id, node_id, token = cont.run_id, cont.node_id, cont.token
+                    run_id, node_id, tok = cont.run_id, cont.node_id, cont.token
 
-            if token and run_id and node_id:
+            if tok and run_id and node_id:
                 await container.resume_router.resume(
                     run_id=run_id,
                     node_id=node_id,
-                    token=token,
+                    token=tok,
                     payload={
                         "choice": choice_l,
                         "telegram": {
@@ -142,7 +167,7 @@ async def _process_update(container, payload: dict, token: str):
                 pass
             return
 
-        # Regular messages / uploads
+        # 2) Regular messages / uploads -------------------------------
         msg = payload.get("message")
         if not msg:
             return
@@ -153,9 +178,11 @@ async def _process_update(container, payload: dict, token: str):
         chat_id = chat.get("id")
         topic_id = msg.get("message_thread_id")
         ch_key = _channel_key(chat_id, topic_id)
+        scheme, channel_id = _tg_scheme_and_channel_id(chat_id, topic_id)
+
         text = (msg.get("text") or msg.get("caption") or "") or ""
 
-        files: list[dict[str, Any]] = []
+        tg_files: list[dict[str, Any]] = []
 
         # Photos
         photos = msg.get("photo") or []
@@ -171,7 +198,7 @@ async def _process_update(container, payload: dict, token: str):
                     uri = await _stage_and_save(
                         container, data=data, name=name, ch_key=ch_key, cont=None
                     )
-                    files.append(
+                    tg_files.append(
                         _file_ref(
                             file_id=file_id,
                             name=name,
@@ -198,8 +225,10 @@ async def _process_update(container, payload: dict, token: str):
             if file_path:
                 try:
                     data = await _tg_download_file(file_path, token)
-                    uri = _stage_and_save(container, data=data, name=name, ch_key=ch_key, cont=None)
-                    files.append(
+                    uri = await _stage_and_save(
+                        container, data=data, name=name, ch_key=ch_key, cont=None
+                    )
+                    tg_files.append(
                         _file_ref(
                             file_id=file_id,
                             name=name,
@@ -215,29 +244,49 @@ async def _process_update(container, payload: dict, token: str):
                         f"Telegram document download failed: {e}"
                     )
 
-        if files:
-            await _append_inbox(container, ch_key, files)
+        # Turn Telegram file_refs into IncomingFile with pre-saved URIs
+        incoming_files: list[IncomingFile] = []
+        for fr in tg_files:
+            incoming_files.append(
+                IncomingFile(
+                    id=fr["id"],
+                    name=fr["name"],
+                    mimetype=fr.get("mimetype"),
+                    size=fr.get("size"),
+                    uri=fr.get("uri"),  # already staged as artifact
+                    url=None,  # no re-download
+                    extra={
+                        "platform": "telegram",
+                        "channel_key": fr.get("channel_key"),
+                        "ts": fr.get("ts"),
+                    },
+                )
+            )
+
+        meta = {
+            "raw": payload,
+            "channel_key": ch_key,
+            "telegram": {
+                "message_id": msg.get("message_id"),
+                "chat_id": chat_id,
+            },
+        }
+
+        resumed = await ingress.handle(
+            IncomingMessage(
+                scheme=scheme,
+                channel_id=channel_id,
+                thread_id=str(topic_id or ""),
+                text=text,
+                files=incoming_files or None,
+                meta=meta,
+            )
+        )
 
-        # Look up continuation by thread-scoped correlator (message-less)
-        cont = None
-        corr = Correlator(scheme="tg", channel=ch_key, thread=str(topic_id or ""), message="")
-        cont = await container.cont_store.find_by_correlator(corr=corr)
         container.logger and container.logger.for_run().debug(
-            f"[TG] inbound: text='{text}' files={len(files)} cont={bool(cont)}"
+            f"[TG] inbound: text={text!r} files={len(incoming_files)} resumed={resumed}"
         )
 
-        if not cont:
-            return
-
-        payload_out = {
-            "text": text,
-            "telegram": {"message_id": msg.get("message_id"), "chat_id": chat_id},
-        }
-        if cont.kind in ("user_files", "user_input_or_files"):
-            payload_out["files"] = files
-
-        await container.resume_router.resume(cont.run_id, cont.node_id, cont.token, payload_out)
-
     except Exception as e:
         container.logger and container.logger.for_run().error(
             f"Telegram inbound processing error: {e}", exc_info=True
@@ -281,7 +330,8 @@ def _normalize_mime_by_name(name: str | None, hint: str | None) -> str:
 
 
 async def _stage_and_save(container, *, data: bytes, name: str, ch_key: str, cont) -> str:
-    tmp = container.artifacts.tmp_path(suffix=f"_{name}")
+    tmp = await container.artifacts.plan_staging_path(planned_ext=f"_{name}")
+
     with open(tmp, "wb") as f:
         f.write(data)
     run_id = cont.run_id if cont else "ad-hoc"
@@ -313,12 +363,3 @@ def _file_ref(
         "channel_key": ch_key,
         "ts": ts,
     }
-
-
-async def _append_inbox(container, ch_key: str, file_refs: list[dict[str, Any]]):
-    kv = getattr(container, "kv_hot", None)
-    if kv:
-        await kv.list_append_unique(f"inbox://{ch_key}", file_refs, id_key="id")
-    else:
-        logger = getattr(container, "logger", None)
-        logger and logger.for_run().warning("No KV present; uploads inbox not stored.")

aethergraph/plugins/channel/websockets/weibui_ws.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+from typing import Any
+
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+
+from aethergraph.api.v1.deps import RequestIdentity  # adjust import
+from aethergraph.core.runtime.runtime_services import current_services
+from aethergraph.services.eventhub.event_hub import EventHub
+
+"""
+WebSocket endpoint for pushing EventLog rows to the browser in real time.
+
+Protocol (JSON messages from client):
+
+  { "type": "subscribe",
+    "scope_id": "session:<id>",
+    "kinds": ["session_chat"] }
+
+  { "type": "unsubscribe",
+    "scope_id": "session:<id>",
+    "kinds": ["session_chat"] }
+
+  { "type": "ping" }
+
+Messages from server:
+
+  { "type": "event",
+    "scope_id": "session:<id>",
+    "kind": "session_chat",
+    "id": "<event-id>",
+    "ts": <float>,
+    "payload": { ...same as HTTP /chat/events... }
+  }
+
+  { "type": "pong" }
+
+NOTE: This is a scaffold. It is *not* yet wired into auth or your router.
+"""
+
+
+router = APIRouter()
+
+
+@router.websocket("/ws/events")
+async def ws_events(
+    websocket: WebSocket,
+    identity: RequestIdentity = None,  # TODO: hook in proper auth if desired
+) -> None:
+    """
+    WebSocket endpoint for UI event streaming.
+
+    Typical usage (client-side, future):
+
+      ws = new WebSocket("wss://.../ws/events");
+      ws.send(JSON.stringify({
+        type: "subscribe",
+        scope_id: "session:<session_id>",
+        kinds: ["session_chat"],
+      }));
+
+    For now this is scaffold-only and not used by the frontend.
+    """
+    await websocket.accept()
+
+    container = current_services()
+    event_hub: EventHub | None = getattr(container, "event_hub", None)
+
+    if event_hub is None:
+        # If EventHub hasn't been wired yet, just close gracefully.
+        await websocket.close(code=1011)
+        return
+
+    # (scope_id, kind) -> callback
+    callbacks: dict[tuple[str, str], Any] = {}
+
+    # Queue of rows to send to this client
+    queue: asyncio.Queue[dict] = asyncio.Queue()
+
+    async def make_callback(scope_id: str, kind: str):
+        async def _cb(row: dict) -> None:
+            """
+            Called by EventHub.broadcast(row).
+
+            We avoid calling websocket.send_json directly here to keep ordering
+            and error-handling in a single place (the sender task).
+            """
+            await queue.put(row)
+
+        return _cb
+
+    async def sender() -> None:
+        """
+        Background task that forwards rows from the queue to the WebSocket.
+        """
+        try:
+            while True:
+                row = await queue.get()
+                # Minimal envelope; payload matches HTTP /chat/events structure.
+                await websocket.send_json(
+                    {
+                        "type": "event",
+                        "scope_id": row.get("scope_id"),
+                        "kind": row.get("kind"),
+                        "id": row.get("id"),
+                        "ts": row.get("ts"),
+                        "payload": row.get("payload") or {},
+                    }
+                )
+        except WebSocketDisconnect:
+            # Client went away; main function will handle cleanup.
+            return
+        except Exception:
+            # TODO: log error
+            return
+
+    sender_task = asyncio.create_task(sender())
+
+    async def subscribe(scope_id: str, kinds: list[str]) -> None:
+        for kind in kinds:
+            key = (scope_id, kind)
+            if key in callbacks:
+                continue
+            cb = await make_callback(scope_id, kind)
+            callbacks[key] = cb
+            event_hub.subscribe(scope_id, kind, cb)
+
+    async def unsubscribe(scope_id: str, kinds: list[str]) -> None:
+        for kind in kinds:
+            key = (scope_id, kind)
+            cb = callbacks.pop(key, None)
+            if cb is not None:
+                event_hub.unsubscribe(scope_id, kind, cb)
+
+    try:
+        while True:
+            msg = await websocket.receive_json()
+
+            msg_type = msg.get("type")
+            if msg_type == "subscribe":
+                scope_id = msg["scope_id"]
+                kinds = msg.get("kinds") or ["session_chat"]
+                # TODO: enforce authorization here based on `identity` & scope_id
+                await subscribe(scope_id, kinds)
+
+            elif msg_type == "unsubscribe":
+                scope_id = msg["scope_id"]
+                kinds = msg.get("kinds") or ["session_chat"]
+                await unsubscribe(scope_id, kinds)
+
+            elif msg_type == "ping":
+                await websocket.send_json({"type": "pong"})
+
+            # else: ignore unknown types for now
+
+    except WebSocketDisconnect:
+        # Normal disconnect
+        pass
+    except Exception:
+        # TODO: log error
+        pass
+    finally:
+        # Cleanup subscriptions and sender task
+        for (scope_id, kind), cb in callbacks.items():
+            event_hub.unsubscribe(scope_id, kind, cb)
+        callbacks.clear()
+
+        sender_task.cancel()
+        with contextlib.suppress(Exception):
+            await sender_task