machinaos 0.0.78 → 0.0.80

package/server/nodes/telegram/_events.py

@@ -0,0 +1,167 @@
+"""Wave 12 B3: CloudEvents factories + broadcaster wrappers for telegram.
+
+Plugin-specific event emission — replaces:
+  - ``broadcaster.update_telegram_status(...)`` call inside the
+    telegram service's ``_broadcast_status`` method
+  - ``event_waiter.dispatch("telegram_message_received", event_data)``
+    inside the message-receive handler
+
+After B3 every telegram wire frame originates from one wrapper here —
+single source of truth for shape. The cross-plugin
+``_emit_connection_typed`` helper on ``StatusBroadcaster`` retires in
+the same commit since android (B1) + whatsapp (B2) + telegram (B3) are
+the only callers.
+
+Per RFC plugin_authoring_rfc.md §6.4: plugin-specific factories live in
+the plugin folder.
+
+Wire format (Wave 12 D4 — legacy ``telegram_status`` raw frame retired):
+  - Status: typed CloudEvent on ``plugin_connection_status`` (FE routes
+    by ``envelope.source``).
+  - Message: typed CloudEvent dispatched to ``event_waiter`` so
+    ``telegramReceive`` trigger nodes match it; legacy wire key
+    ``telegram_message_received`` preserved for FE.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, Mapping, Optional
+
+from services.events.envelope import WorkflowEvent
+
+
+# ---- Wire-routing keys -----------------------------------------------------
+
+_STATUS_TYPED_WIRE_KEY = "plugin_connection_status"
+
+# Legacy event_type the event_waiter dispatches by; trigger nodes
+# subscribe on this string. Keep until Phase B11 FE migration.
+_MESSAGE_LEGACY_EVENT_TYPE = "telegram_message_received"
+
+
+# ---- Typed factories (plugin-specific per RFC §6.4) ------------------------
+
+
+def telegram_connection_status(
+    *,
+    connected: bool,
+    bot_id: Optional[int] = None,
+    bot_username: Optional[str] = None,
+    bot_name: Optional[str] = None,
+    owner_chat_id: Optional[int] = None,
+    has_stored_token: Optional[bool] = None,
+) -> WorkflowEvent:
+    """Bot connection-state envelope. ``subject`` is the bot username
+    so the FE can route per-bot updates.
+
+    ``has_stored_token`` distinguishes "not connected, no token stored"
+    (user hasn't added a token yet) from "not connected, token stored
+    but bot offline" (network failure / token revoked). Used by the
+    auto-reconnect refresh callback (see :mod:`._refresh`).
+    """
+    data: Dict[str, Any] = {
+        "connected": connected,
+        "bot_id": bot_id,
+        "bot_username": bot_username,
+        "bot_name": bot_name,
+        "owner_chat_id": owner_chat_id,
+    }
+    if has_stored_token is not None:
+        data["has_stored_token"] = has_stored_token
+    return WorkflowEvent(
+        source="machinaos://nodes/telegram",
+        type=("com.machinaos.telegram.connection.opened" if connected else "com.machinaos.telegram.connection.closed"),
+        subject=bot_username,
+        data=data,
+    )
+
+
+def telegram_message_received(event_data: Mapping[str, Any]) -> WorkflowEvent:
+    """Incoming Telegram message envelope. ``subject`` is the chat_id
+    (cast to str — Telegram chat IDs are numeric, the envelope spec
+    requires a string subject)."""
+    payload = dict(event_data)
+    chat_id = payload.get("chat_id")
+    return WorkflowEvent(
+        source="machinaos://nodes/telegram",
+        type="com.machinaos.telegram.message.received",
+        subject=str(chat_id) if chat_id is not None else None,
+        data=payload,
+    )
+
+
+# ---- Broadcaster wrappers --------------------------------------------------
+
+
+async def broadcast_telegram_status(
+    *,
+    connected: bool,
+    bot_id: Optional[int] = None,
+    bot_username: Optional[str] = None,
+    bot_name: Optional[str] = None,
+    owner_chat_id: Optional[int] = None,
+    has_stored_token: Optional[bool] = None,
+) -> None:
+    """Update the telegram status cache + emit the typed
+    ``plugin_connection_status`` CloudEvents envelope.
+
+    Replaces ``StatusBroadcaster.update_telegram_status``. Legacy raw
+    ``telegram_status`` frame retired in Wave 12 D4 — FE consumes via
+    the envelope-aware ``plugin_connection_status`` case.
+    """
+    from services.status_broadcaster import get_status_broadcaster
+
+    broadcaster = get_status_broadcaster()
+
+    payload: Dict[str, Any] = {
+        "connected": connected,
+        "bot_id": bot_id,
+        "bot_username": bot_username,
+        "bot_name": bot_name,
+        "owner_chat_id": owner_chat_id,
+        "timestamp": time.time(),
+    }
+    if has_stored_token is not None:
+        payload["has_stored_token"] = has_stored_token
+    broadcaster._status["telegram"] = payload
+
+    event = telegram_connection_status(
+        connected=connected,
+        bot_id=bot_id,
+        bot_username=bot_username,
+        bot_name=bot_name,
+        owner_chat_id=owner_chat_id,
+        has_stored_token=has_stored_token,
+    )
+    await broadcaster.broadcast(
+        {
+            "type": _STATUS_TYPED_WIRE_KEY,
+            "data": event.model_dump(mode="json"),
+        }
+    )
+
+
+async def dispatch_telegram_message_received(event_data: Mapping[str, Any]) -> None:
+    """Dispatch an incoming Telegram message via the canary CloudEvents path.
+
+    Single delivery: :func:`services.events.dispatch.emit` Signals running
+    :class:`TriggerListenerWorkflow` consumers via Temporal Visibility AND
+    broadcasts the envelope to FE on the ``telegram_message_received``
+    wire key. telegramReceive is canary-registered so no legacy
+    ``event_waiter`` waiter is ever registered for it.
+    """
+    from services.events.dispatch import emit
+
+    await emit(
+        telegram_message_received(dict(event_data)),
+        wire_routing_key=_MESSAGE_LEGACY_EVENT_TYPE,
+    )
+
+
+__all__ = [
+    "broadcast_telegram_status",
+    "dispatch_telegram_message_received",
+    "telegram_connection_status",
+    "telegram_message_received",
+]

package/server/nodes/telegram/_filters.py

@@ -55,16 +55,11 @@ def build_telegram_filter(params: Dict) -> Callable[[Dict], bool]:
     content_type_filter = params.get("content_type_filter", "all")
     chat_id_filter = params.get("chat_id", "")
     from_user_filter = params.get("from_user", "")
-    keywords = [
-        k.strip().lower() for k in params.get("keywords", "").split(",") if k.strip()
-    ]
+    keywords = [k.strip().lower() for k in params.get("keywords", "").split(",") if k.strip()]
     ignore_bots = params.get("ignore_bots", True)
     owner_chat_id = params.get("_owner_chat_id")
 
-    logger.debug(
-        f"[TelegramFilter] Built: sender={sender_filter}, "
-        f"content_type={content_type_filter}, owner_chat_id={owner_chat_id}"
-    )
+    logger.debug(f"[TelegramFilter] Built: sender={sender_filter}, " f"content_type={content_type_filter}, owner_chat_id={owner_chat_id}")
 
     def _get_owner_chat_id() -> object:
         """Lazy lookup from the local service -- handles owner detected
@@ -113,10 +108,7 @@ def build_telegram_filter(params: Dict) -> Callable[[Dict], bool]:
         if sender_filter != "self" and ignore_bots and m.get("is_bot", False):
             return False
 
-        logger.debug(
-            f"[TelegramFilter] Matched message from "
-            f"{m.get('from_username', m.get('from_id'))}"
-        )
+        logger.debug(f"[TelegramFilter] Matched message from " f"{m.get('from_username', m.get('from_id'))}")
         return True
 
     return matches

package/server/nodes/telegram/_handlers.py

@@ -38,7 +38,9 @@ def _send_text(svc, data, parse_mode):
     if not text:
         return None, "text required for text message"
     return svc.send_message(
-        chat_id=data["chat_id"], text=text, parse_mode=parse_mode,
+        chat_id=data["chat_id"],
+        text=text,
+        parse_mode=parse_mode,
     ), None
 
 
@@ -47,8 +49,10 @@ def _send_photo(svc, data, parse_mode):
     if not photo_url:
         return None, "media_url required for photo"
     return svc.send_photo(
-        chat_id=data["chat_id"], photo=photo_url,
-        caption=data.get("caption"), parse_mode=parse_mode,
+        chat_id=data["chat_id"],
+        photo=photo_url,
+        caption=data.get("caption"),
+        parse_mode=parse_mode,
     ), None
 
 
@@ -57,8 +61,10 @@ def _send_document(svc, data, parse_mode):
     if not doc_url:
         return None, "media_url required for document"
     return svc.send_document(
-        chat_id=data["chat_id"], document=doc_url,
-        caption=data.get("caption"), parse_mode=parse_mode,
+        chat_id=data["chat_id"],
+        document=doc_url,
+        caption=data.get("caption"),
+        parse_mode=parse_mode,
     ), None
 
 
@@ -67,7 +73,9 @@ def _send_location(svc, data, parse_mode):
     if lat is None or lon is None:
         return None, "latitude and longitude required"
     return svc.send_location(
-        chat_id=data["chat_id"], latitude=float(lat), longitude=float(lon),
+        chat_id=data["chat_id"],
+        latitude=float(lat),
+        longitude=float(lon),
     ), None
 
 
@@ -76,7 +84,9 @@ def _send_contact(svc, data, parse_mode):
     if not phone or not first_name:
         return None, "phone_number and first_name required"
     return svc.send_contact(
-        chat_id=data["chat_id"], phone_number=phone, first_name=first_name,
+        chat_id=data["chat_id"],
+        phone_number=phone,
+        first_name=first_name,
         last_name=data.get("last_name"),
     ), None
 

package/server/nodes/telegram/_refresh.py

@@ -15,7 +15,7 @@ into the broadcaster cache.
 from __future__ import annotations
 
 import logging
-from typing import Any, Dict, TYPE_CHECKING
+from typing import Dict, TYPE_CHECKING
 
 from opentelemetry import trace
 
@@ -32,55 +32,49 @@ async def refresh_telegram_status(broadcaster: "StatusBroadcaster") -> None:
     Called once per ``_refresh_all_services`` cycle. OTel span emitted
     so cold-start ``getMe`` time is observable -- the historical
     bottleneck on local DNS for the first WebSocket connect.
+
+    Wave 12 B3: routes through plugin _events.py wrapper. Cache write
+    + dual-emit (legacy raw + typed sibling) all in one call.
     """
     with tracer.start_as_current_span("broadcaster.refresh_telegram") as span:
         try:
+            from ._events import broadcast_telegram_status
             from ._service import get_telegram_service
 
             service = get_telegram_service()
 
-            def _snapshot(connected: bool, has_token: bool) -> Dict[str, Any]:
-                s = service.get_status()
-                return {
-                    "connected": connected,
-                    "bot_id": s.get("bot_id") if connected else None,
-                    "bot_username": s.get("bot_username") if connected else None,
-                    "bot_name": s.get("bot_name") if connected else None,
-                    "owner_chat_id": s.get("owner_chat_id") if connected else None,
-                    "has_stored_token": has_token,
-                }
+            async def _emit(connected: bool, has_token: bool) -> None:
+                """Snapshot service state and broadcast (cache write + WS)."""
+                s = service.get_status() if connected else {}
+                await broadcast_telegram_status(
+                    connected=connected,
+                    bot_id=s.get("bot_id") if connected else None,
+                    bot_username=s.get("bot_username") if connected else None,
+                    bot_name=s.get("bot_name") if connected else None,
+                    owner_chat_id=s.get("owner_chat_id") if connected else None,
+                    has_stored_token=has_token,
+                )
 
             if service.connected:
-                broadcaster._status["telegram"] = _snapshot(True, True)
+                await _emit(True, True)
                 span.set_attribute("path", "already_connected")
             elif not await service.has_stored_token():
-                broadcaster._status["telegram"] = _snapshot(False, False)
+                await _emit(False, False)
                 span.set_attribute("path", "no_token")
             else:
                 span.set_attribute("path", "auto_reconnect")
                 logger.info("[StatusBroadcaster] Auto-reconnecting Telegram bot...")
                 result = await service.connect()
                 ok = bool(result.get("success"))
-                broadcaster._status["telegram"] = _snapshot(ok, True)
+                await _emit(ok, True)
                 span.set_attribute("reconnect_ok", ok)
                 if ok:
                     bot_username = broadcaster._status["telegram"].get("bot_username")
-                    logger.info(
-                        f"[StatusBroadcaster] Telegram auto-reconnected: @{bot_username}"
-                    )
+                    logger.info(f"[StatusBroadcaster] Telegram auto-reconnected: @{bot_username}")
                 else:
-                    logger.warning(
-                        f"[StatusBroadcaster] Telegram auto-reconnect failed: "
-                        f"{result.get('error')}"
-                    )
-
-            await broadcaster.broadcast({
-                "type": "telegram_status",
-                "data": broadcaster._status["telegram"],
-            })
-            span.set_attribute(
-                "connected", bool(broadcaster._status["telegram"]["connected"])
-            )
+                    logger.warning(f"[StatusBroadcaster] Telegram auto-reconnect failed: " f"{result.get('error')}")
+
+            span.set_attribute("connected", bool(broadcaster._status["telegram"]["connected"]))
         except Exception as e:
             span.record_exception(e)
             logger.debug(f"[StatusBroadcaster] Could not refresh Telegram status: {e}")
@@ -98,9 +92,5 @@ async def precheck_telegram_trigger(parameters: Dict) -> str | None:
     if not service.connected:
         return "Telegram bot not connected. Add bot token in Credentials."
     sender_filter = parameters.get("sender_filter", "all")
-    logger.info(
-        "[TelegramTrigger] starting "
-        f"sender_filter={sender_filter} "
-        f"owner_detected={service.owner_chat_id is not None}"
-    )
+    logger.info("[TelegramTrigger] starting " f"sender_filter={sender_filter} " f"owner_detected={service.owner_chat_id is not None}")
     return None

package/server/nodes/telegram/_service.py

@@ -30,7 +30,7 @@ Public surface (consumed by `_handlers.py`, `telegram_send.py`,
                                                     handlers.
 
 Auth lookups go through :class:`TelegramCredential.resolve` (lifted from
-the per-key ``auth.get_api_key("telegram_bot_token")`` / ``..._owner_chat_id``
+the per-key ``auth.get_api_key("telegram")`` / ``..._owner_chat_id``
 calls scattered across the previous handler/router code).  The credential
 class stays declarative — :class:`ApiKeyCredential` does the heavy lifting,
 this service just consumes the resolved dict.
@@ -165,7 +165,7 @@ class TelegramService(ServiceSingleton):
     # =========================================================================
 
     async def has_stored_token(self) -> bool:
-        """Whether `telegram_bot_token` is persisted in auth credentials."""
+        """Whether the `telegram` bot-token credential is persisted in auth."""
         try:
             secrets = await TelegramCredential.resolve()
             return bool(secrets.get("api_key"))
@@ -175,17 +175,16 @@ class TelegramService(ServiceSingleton):
     async def connect(self, token: Optional[str] = None) -> Dict[str, Any]:
         """Connect to Telegram with bot token and start polling.
 
-        When ``token`` is omitted, falls back to the stored
-        ``telegram_bot_token`` credential — matches the Twitter/Google
-        OAuth pattern where the frontend saves credentials first and then
-        calls connect.
+        When ``token`` is omitted, falls back to the stored ``telegram``
+        bot-token credential — matches the Twitter/Google OAuth pattern
+        where the frontend saves credentials first and then calls connect.
 
         Idempotent: if already connected, returns success without tearing
         down the working bot.  See the in-line comment block for the race
         this guards against.
         """
         # Resolve credentials via the declarative class instead of raw
-        # ``auth.get_api_key("telegram_bot_token")`` / ``..._owner_chat_id``
+        # ``auth.get_api_key("telegram")`` / ``..._owner_chat_id``
         # lookups.  Keeps the credential id in one place.
         secrets: Dict[str, Any] = {}
         if not token:
@@ -204,15 +203,12 @@ class TelegramService(ServiceSingleton):
             # tasks fired on overlapping WebSocket connects.
             if self._connected:
                 logger.debug(
-                    "[Telegram] connect() called while already connected to "
-                    f"@{self._bot_info.get('username')}, returning success",
+                    "[Telegram] connect() called while already connected to " f"@{self._bot_info.get('username')}, returning success",
                 )
                 return {
                     "success": True,
                     "bot": self._bot_info,
-                    "message": (
-                        f"Already connected to @{self._bot_info.get('username')}"
-                    ),
+                    "message": (f"Already connected to @{self._bot_info.get('username')}"),
                 }
 
             try:
@@ -241,9 +237,7 @@ class TelegramService(ServiceSingleton):
                 )
                 self._bot = self._application.bot
                 self._token = token
-                self._application.add_handler(
-                    MessageHandler(filters.ALL, self._on_message_received)
-                )
+                self._application.add_handler(MessageHandler(filters.ALL, self._on_message_received))
 
                 await self._application.initialize()
 
@@ -265,9 +259,7 @@ class TelegramService(ServiceSingleton):
                 saved_owner = secrets.get("telegram_owner_chat_id")
                 if saved_owner is None:
                     try:
-                        saved_owner = (await TelegramCredential.resolve()).get(
-                            "telegram_owner_chat_id"
-                        )
+                        saved_owner = (await TelegramCredential.resolve()).get("telegram_owner_chat_id")
                     except PermissionError:
                         saved_owner = None
                 if saved_owner:
@@ -411,6 +403,7 @@ class TelegramService(ServiceSingleton):
             captured_id = m.from_user.id
             try:
                 from services.plugin.deps import get_auth_service
+
                 await get_auth_service().store_api_key(
                     "telegram_owner_chat_id",
                     str(captured_id),
@@ -425,10 +418,7 @@ class TelegramService(ServiceSingleton):
                 )
                 return
             self._owner_chat_id = captured_id
-            logger.info(
-                f"[Telegram] Owner retroactively captured from pending "
-                f"updates: @{m.from_user.username} (ID: {captured_id})"
-            )
+            logger.info(f"[Telegram] Owner retroactively captured from pending " f"updates: @{m.from_user.username} (ID: {captured_id})")
             return
 
     async def _on_message_received(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
@@ -449,15 +439,12 @@ class TelegramService(ServiceSingleton):
             # what went wrong. The new order preserves the invariant
             # "in-memory has owner => DB has owner" so a restart can
             # always re-capture from the next inbound private message.
-            if (
-                self._owner_chat_id is None
-                and msg.chat.type == "private"
-                and msg.from_user
-            ):
+            if self._owner_chat_id is None and msg.chat.type == "private" and msg.from_user:
                 captured_id = msg.from_user.id
                 persist_ok = False
                 try:
                     from services.plugin.deps import get_auth_service
+
                     await get_auth_service().store_api_key(
                         "telegram_owner_chat_id",
                         str(captured_id),
@@ -481,10 +468,7 @@ class TelegramService(ServiceSingleton):
                     )
                 if persist_ok:
                     self._owner_chat_id = captured_id
-                    logger.info(
-                        f"[Telegram] Owner detected and persisted: "
-                        f"@{msg.from_user.username} (ID: {captured_id})"
-                    )
+                    logger.info(f"[Telegram] Owner detected and persisted: " f"@{msg.from_user.username} (ID: {captured_id})")
                     await self._broadcast_status()
 
             event_data = self._format_message(msg)
@@ -494,9 +478,11 @@ class TelegramService(ServiceSingleton):
                 f"chat_type={event_data.get('chat_type')}"
             )
 
-            from services import event_waiter
-            resolved = event_waiter.dispatch("telegram_message_received", event_data)
-            logger.info(f"[Telegram] Dispatched to {resolved} waiter(s)")
+            # Route via plugin _events.py wrapper — canary CloudEvents
+            # path (Visibility-query Signal + WS broadcast).
+            from . import dispatch_telegram_message_received
+
+            await dispatch_telegram_message_received(event_data)
         except Exception as e:
             logger.error(f"[Telegram] Message handler error: {e}")
 
@@ -570,9 +556,10 @@ class TelegramService(ServiceSingleton):
 
     async def _broadcast_status(self):
         try:
-            from services.status_broadcaster import get_status_broadcaster
-            broadcaster = get_status_broadcaster()
-            await broadcaster.update_telegram_status(
+            # Wave 12 B3: route via plugin _events.py wrapper.
+            from . import broadcast_telegram_status
+
+            await broadcast_telegram_status(
                 connected=self._connected,
                 bot_id=self._bot_info.get("id"),
                 bot_username=self._bot_info.get("username"),
@@ -601,12 +588,11 @@ class TelegramService(ServiceSingleton):
         if not text:
             return text, "HTML"
         from services.markdown_formatter import to_telegram_html
+
         return to_telegram_html(text), "HTML"
 
     @classmethod
-    def _resolve_body(
-        cls, body: Optional[str], parse_mode: Optional[str]
-    ) -> tuple[Optional[str], Optional[str]]:
+    def _resolve_body(cls, body: Optional[str], parse_mode: Optional[str]) -> tuple[Optional[str], Optional[str]]:
         """Apply parse-mode preprocessing to a text/caption.  Returns
         ``(body, effective_parse_mode)``."""
         if parse_mode == "Auto":
@@ -636,10 +622,7 @@ class TelegramService(ServiceSingleton):
             )
         except BadRequest as e:
             if "can't parse entities" in str(e).lower() and effective_pm:
-                logger.warning(
-                    f"[Telegram] Parse mode {effective_pm} failed for "
-                    f"{method.__name__}, sending as plain text"
-                )
+                logger.warning(f"[Telegram] Parse mode {effective_pm} failed for " f"{method.__name__}, sending as plain text")
                 return await method(
                     **{body_kw: body},
                     parse_mode=None,
@@ -670,7 +653,8 @@ class TelegramService(ServiceSingleton):
         if len(chunks) > 1:
             logger.info(
                 "[Telegram] Splitting %d-char message into %d parts",
-                len(text), len(chunks),
+                len(text),
+                len(chunks),
             )
 
         first_msg: Any = None

package/server/nodes/telegram/meta.json

@@ -0,0 +1,3 @@
+{
+  "color": "#0088CC"
+}

package/server/nodes/telegram/telegram.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="#0088CC">
+  <path d="M11.944 0A12 12 0 0 0 0 12a12 12 0 0 0 12 12 12 12 0 0 0 12-12A12 12 0 0 0 12 0a12 12 0 0 0-.056 0zm4.962 7.224c.1-.002.321.023.465.14a.506.506 0 0 1 .171.325c.016.093.036.306.02.472-.18 1.898-.962 6.502-1.36 8.627-.168.9-.499 1.201-.82 1.23-.696.065-1.225-.46-1.9-.902-1.056-.693-1.653-1.124-2.678-1.8-1.185-.78-.417-1.21.258-1.91.177-.184 3.247-2.977 3.307-3.23.007-.032.014-.15-.056-.212s-.174-.041-.249-.024c-.106.024-1.793 1.14-5.061 3.345-.48.33-.913.49-1.302.48-.428-.008-1.252-.241-1.865-.44-.752-.245-1.349-.374-1.297-.789.027-.216.325-.437.893-.663 3.498-1.524 5.83-2.529 6.998-3.014 3.332-1.386 4.025-1.627 4.476-1.635z"/>
+</svg>

package/server/nodes/telegram/telegram_receive.py

@@ -23,15 +23,31 @@ class TelegramReceiveParams(BaseModel):
     """
 
     content_type_filter: Literal[
-        "all", "text", "photo", "video", "audio", "voice", "document",
-        "sticker", "location", "contact", "poll",
+        "all",
+        "text",
+        "photo",
+        "video",
+        "audio",
+        "voice",
+        "document",
+        "sticker",
+        "location",
+        "contact",
+        "poll",
     ] = Field(
         default="all",
         description="Filter by message content type",
     )
     sender_filter: Literal[
-        "all", "self", "private", "group", "supergroup", "channel",
-        "specific_chat", "specific_user", "keywords",
+        "all",
+        "self",
+        "private",
+        "group",
+        "supergroup",
+        "channel",
+        "specific_chat",
+        "specific_user",
+        "keywords",
     ] = Field(
         default="all",
         description="Filter which messages trigger the workflow",
@@ -61,10 +77,20 @@ class TelegramReceiveParams(BaseModel):
         default=True,
         description="Do not trigger on messages from other bots",
         json_schema_extra={
-            "displayOptions": {"show": {"sender_filter": [
-                "all", "private", "group", "supergroup", "channel",
-                "specific_chat", "specific_user", "keywords",
-            ]}},
+            "displayOptions": {
+                "show": {
+                    "sender_filter": [
+                        "all",
+                        "private",
+                        "group",
+                        "supergroup",
+                        "channel",
+                        "specific_chat",
+                        "specific_user",
+                        "keywords",
+                    ]
+                }
+            },
         },
     )
 
@@ -100,10 +126,7 @@ class TelegramReceiveNode(TriggerNode):
     group = ("social", "trigger")
     description = "Trigger workflow when Telegram message is received"
     component_kind = "trigger"
-    handles = (
-        {"name": "output-main", "kind": "output", "position": "right",
-         "label": "Output", "role": "main"},
-    )
+    handles = ({"name": "output-main", "kind": "output", "position": "right", "label": "Output", "role": "main"},)
     credentials = (TelegramCredential,)
     task_queue = TaskQueue.TRIGGERS_EVENT
     mode = "event"
@@ -116,6 +139,7 @@ class TelegramReceiveNode(TriggerNode):
         # Delegate to legacy filter builder for full feature parity —
         # 11.F ports the body and removes the legacy registry entry.
         from services.event_waiter import build_telegram_filter
+
         return build_telegram_filter(params.model_dump())
 
     async def execute(
@@ -136,14 +160,10 @@ class TelegramReceiveNode(TriggerNode):
         if not getattr(svc, "connected", False):
             return self._wrap_error(
                 start_time=time.time(),
-                error=(
-                    "Telegram bot not connected. Add bot token in Credentials."
-                ),
+                error=("Telegram bot not connected. Add bot token in Credentials."),
             )
         return await super().execute(node_id, parameters, context)
 
     @Operation("wait")
     async def wait(self, ctx: NodeContext, params: TelegramReceiveParams) -> TelegramReceiveOutput:
-        raise NotImplementedError(
-            "Event triggers return via TriggerNode.execute, not the op body"
-        )
+        raise NotImplementedError("Event triggers return via TriggerNode.execute, not the op body")