machinaos 0.0.76 → 0.0.78

package/server/nodes/visuals.json

@@ -1,4 +1,9 @@
 {
+  "agentBuilder": {
+    "icon": "🛠️",
+    "color": "#ffb86c",
+    "skill": "agent-builder-skill"
+  },
   "aiAgent": {
     "icon": "🤖",
     "color": "#bd93f9"
@@ -8,7 +13,8 @@
     "color": "#bd93f9"
   },
   "airplaneModeControl": {
-    "icon": "✈️"
+    "icon": "✈️",
+    "color": "#50fa7b"
   },
   "android_agent": {
     "icon": "📱",
@@ -25,15 +31,18 @@
   },
   "appLauncher": {
     "icon": "🚀",
-    "skill": "app-launcher-skill"
+    "skill": "app-launcher-skill",
+    "color": "#50fa7b"
   },
   "appList": {
     "icon": "📋",
-    "skill": "app-list-skill"
+    "skill": "app-list-skill",
+    "color": "#50fa7b"
   },
   "audioAutomation": {
     "icon": "🔊",
-    "skill": "audio-skill"
+    "skill": "audio-skill",
+    "color": "#50fa7b"
   },
   "autonomous_agent": {
     "icon": "🎯",
@@ -41,11 +50,13 @@
   },
   "batteryMonitor": {
     "icon": "🔋",
-    "skill": "battery-skill"
+    "skill": "battery-skill",
+    "color": "#50fa7b"
   },
   "bluetoothAutomation": {
     "icon": "🔵",
-    "skill": "bluetooth-skill"
+    "skill": "bluetooth-skill",
+    "color": "#50fa7b"
   },
   "braveSearch": {
     "icon": "asset:brave",
@@ -63,7 +74,8 @@
   },
   "cameraControl": {
     "icon": "📷",
-    "skill": "camera-skill"
+    "skill": "camera-skill",
+    "color": "#50fa7b"
   },
   "cerebrasChatModel": {
     "icon": "lobehub:cerebras",
@@ -89,6 +101,10 @@
     "icon": "lobehub:Claude",
     "color": "#8be9fd"
   },
+  "codex_agent": {
+    "icon": "lobehub:OpenAI",
+    "color": "#ffb86c"
+  },
   "coding_agent": {
     "icon": "💻",
     "color": "#8be9fd"
@@ -124,7 +140,8 @@
     "color": "#8be9fd"
   },
   "deviceStateAutomation": {
-    "icon": "⚙️"
+    "icon": "⚙️",
+    "color": "#50fa7b"
   },
   "documentParser": {
     "icon": "📄",
@@ -153,7 +170,8 @@
   },
   "environmentalSensors": {
     "icon": "🌡️",
-    "skill": "environmental-skill"
+    "skill": "environmental-skill",
+    "color": "#50fa7b"
   },
   "fileDownloader": {
     "icon": "⬇️",
@@ -245,22 +263,29 @@
   },
   "javascriptExecutor": {
     "icon": "asset:javascript",
-    "skill": "javascript-skill"
+    "skill": "javascript-skill",
+    "color": "#ffb86c"
   },
   "kimiChatModel": {
     "icon": "lobehub:kimi",
     "color": "#bd93f9"
   },
+  "lmstudioChatModel": {
+    "icon": "lobehub:lmstudio",
+    "color": "#4F8EFF"
+  },
   "location": {
     "icon": "📍",
-    "skill": "location-skill"
+    "skill": "location-skill",
+    "color": "#50fa7b"
   },
   "masterSkill": {
     "icon": "🎯",
     "color": "#f1fa8c"
   },
   "mediaControl": {
-    "icon": "🎵"
+    "icon": "🎵",
+    "color": "#50fa7b"
   },
   "mistralChatModel": {
     "icon": "lobehub:mistral",
@@ -268,10 +293,16 @@
   },
   "motionDetection": {
     "icon": "📳",
-    "skill": "motion-skill"
+    "skill": "motion-skill",
+    "color": "#50fa7b"
   },
   "networkMonitor": {
-    "icon": "📡"
+    "icon": "📡",
+    "color": "#50fa7b"
+  },
+  "ollamaChatModel": {
+    "icon": "lobehub:ollama",
+    "color": "#000000"
   },
   "openaiChatModel": {
     "icon": "lobehub:openai",
@@ -318,7 +349,8 @@
   },
   "pythonExecutor": {
     "icon": "asset:python",
-    "skill": "python-skill"
+    "skill": "python-skill",
+    "color": "#ffb86c"
   },
   "rlm_agent": {
     "icon": "🧠",
@@ -326,7 +358,8 @@
   },
   "screenControlAutomation": {
     "icon": "💡",
-    "skill": "screen-control-skill"
+    "skill": "screen-control-skill",
+    "color": "#50fa7b"
   },
   "serperSearch": {
     "icon": "asset:google",
@@ -359,7 +392,8 @@
     "color": "#bd93f9"
   },
   "systemInfo": {
-    "icon": "📱"
+    "icon": "📱",
+    "color": "#50fa7b"
   },
   "taskManager": {
     "icon": "📋",
@@ -427,7 +461,8 @@
     "skill": "twitter-user-skill"
   },
   "typescriptExecutor": {
-    "icon": "asset:typescript"
+    "icon": "asset:typescript",
+    "color": "#ffb86c"
   },
   "vectorStore": {
     "icon": "🗄️",
@@ -461,11 +496,21 @@
   },
   "wifiAutomation": {
     "icon": "📶",
-    "skill": "wifi-skill"
+    "skill": "wifi-skill",
+    "color": "#50fa7b"
   },
   "writeTodos": {
     "icon": "📝",
     "color": "#bd93f9",
     "skill": "write-todos-skill"
+  },
+  "stripeAction": {
+    "icon": "asset:stripe",
+    "color": "#635BFF",
+    "skill": "stripe-skill"
+  },
+  "stripeReceive": {
+    "icon": "asset:stripe",
+    "color": "#635BFF"
   }
 }

package/server/nodes/whatsapp/__init__.py

@@ -4,20 +4,60 @@ Public surface:
     WhatsAppRuntime          - edgymeow Go binary supervisor
     get_whatsapp_runtime()   - singleton accessor (lazy-init via classmethod)
 
-The runtime self-registers with ``services._supervisor.registry`` on
-package import, so ``services._supervisor.shutdown_all_supervisors()``
-called from the FastAPI lifespan will tear it down with all other
-plugin supervisors. No per-plugin lifespan hooks needed.
+Two self-registrations happen on package import:
+
+1. The Go-binary supervisor (``WhatsAppRuntime``) is registered with
+   :mod:`services._supervisor`, so the FastAPI lifespan teardown
+   reaches it via ``shutdown_all_supervisors()``.
+
+2. The WebSocket handler dispatch table (``WS_HANDLERS`` in
+   :mod:`._handlers`) is registered with
+   :mod:`services.ws_handler_registry`, so the central WS router in
+   ``routers/websocket.py`` picks up every ``whatsapp_*`` message type
+   without per-plugin imports. Same pattern as the telegram reference
+   plugin.
 """
 
 from services._supervisor import register_supervisor
+from services.event_waiter import register_filter_builder
+from services.status_broadcaster import register_service_refresh
+from services.ws_handler_registry import (
+    register_option_loader,
+    register_ws_handlers,
+)
 
+from ._filters import build_filter as build_whatsapp_filter
+from ._handlers import WS_HANDLERS
+from ._option_loaders import load_channels, load_group_members, load_groups
+from ._refresh import refresh_whatsapp_status
 from ._runtime import WhatsAppRuntime, get_whatsapp_runtime
 
-# Self-registration: ensures shutdown_all_supervisors() reaches us.
+# Supervisor: ensures shutdown_all_supervisors() reaches us.
 # get_instance() constructs the singleton once (lazy in spawn, not here).
 register_supervisor(WhatsAppRuntime.get_instance())
 
+# WebSocket handlers: 19 message types (status / qr / send / restart /
+# groups / newsletters / chat_history / rate_limit_* / mark_read /
+# typing / presence / diagnostics / stop). Idempotent on re-import.
+register_ws_handlers(WS_HANDLERS)
+
+# Service-status refresh callback (Wave 11.I, milestone J) -- the
+# broadcaster fans out to this on lifespan startup instead of
+# hardcoding the call.
+register_service_refresh(refresh_whatsapp_status)
+
+# Trigger-event filter builder (Wave 11.I, milestone K) -- moved out
+# of services/event_waiter.py so the central FILTER_BUILDERS table
+# carries no plugin-specific code.
+register_filter_builder("whatsappReceive", build_whatsapp_filter)
+
+# loadOptionsMethod loaders (Wave 11.I, milestone M.1) -- self-register
+# into services.ws_handler_registry's option-loader registry, sibling to
+# the WS-handler / router registries.
+register_option_loader("whatsappGroups", load_groups)
+register_option_loader("whatsappChannels", load_channels)
+register_option_loader("whatsappGroupMembers", load_group_members)
+
 __all__ = [
     "WhatsAppRuntime",
     "get_whatsapp_runtime",

package/server/nodes/whatsapp/_base.py

@@ -1,7 +1,7 @@
 """WhatsApp send + DB business logic (Wave 11.D.9 inlined).
 
 Imported by nodes.whatsapp.whatsapp_send and nodes.whatsapp.whatsapp_db.
-RPC dispatch still flows through services.whatsapp_service (HTTP to the Go
+RPC dispatch still flows through nodes.whatsapp._service (HTTP to the Go
 bridge) — extracting that is a separate refactor, not required for the
 plugin migration.
 """
@@ -145,7 +145,7 @@ async def handle_whatsapp_send(
     Returns:
         Execution result dict
     """
-    from services.whatsapp_service import handle_whatsapp_send as whatsapp_send_handler
+    from nodes.whatsapp._service import handle_whatsapp_send as whatsapp_send_handler
     start_time = time.time()
 
     try:
@@ -289,7 +289,7 @@ async def handle_whatsapp_db(
     Returns:
         Execution result dict
     """
-    from services.whatsapp_service import (
+    from nodes.whatsapp._service import (
         handle_whatsapp_chat_history as whatsapp_chat_history_handler,
         whatsapp_rpc_call
     )

package/server/nodes/whatsapp/_filters.py

@@ -0,0 +1,137 @@
+"""WhatsApp event-trigger filter builder (Wave 11.I, milestone K).
+
+Moved verbatim from ``services/event_waiter.build_whatsapp_filter``.
+The plugin's ``__init__.py`` self-registers via
+``event_waiter.register_filter_builder("whatsappReceive", build_filter)``;
+the central event_waiter dispatch table no longer hardcodes this
+plugin's filter.
+
+The filter shape mirrors the event payload shipped by the Go RPC's
+``handleIncomingMessage()`` (see ``service.go``). Snake_case
+parameters throughout — matches the plugin Params with no camelCase
+aliases.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Callable, Dict
+
+logger = logging.getLogger(__name__)
+
+
+def build_filter(params: Dict) -> Callable[[Dict], bool]:
+    """Build filter function for WhatsApp messages.
+
+    Based on Go RPC ``handleIncomingMessage()`` event fields:
+
+    - ``message_id`` -- unique message ID
+    - ``sender`` -- Sender JID (may be LID for groups)
+    - ``sender_phone`` -- RESOLVED phone number (LID already resolved)
+    - ``chat_id`` -- Chat JID (same as sender for DMs, group JID for groups)
+    - ``timestamp`` -- message timestamp
+    - ``is_from_me`` -- true if sent by connected account
+    - ``is_group`` -- true if message is in a group chat
+    - ``message_type`` -- text / image / video / audio / document /
+      sticker / location / contact / contacts
+    - ``text`` -- text content (for text messages)
+    - ``is_forwarded`` -- true if message is forwarded
+    - ``forwarding_score`` -- forwarding count
+    - ``group_info`` -- present for group messages, with ``group_jid``
+      / ``sender_jid`` / ``sender_phone`` / ``sender_name``
+    """
+    msg_type = params.get('message_type_filter', 'all')
+    sender_filter = params.get('filter', 'all')
+    contact_phone = params.get('phone_number', '')
+    group_id = params.get('group_id', '')
+    sender_number = params.get('sender_number', '')
+    keywords = [
+        k.strip().lower()
+        for k in params.get('keywords', '').split(',')
+        if k.strip()
+    ]
+    ignore_own = params.get('ignore_own_messages', True)
+    forwarded_filter = params.get('forwarded_filter', 'all')
+
+    logger.debug(
+        "[WhatsAppFilter] Built: type=%s, filter=%s, group_id=%r, forwarded=%s",
+        msg_type, sender_filter, group_id, forwarded_filter,
+    )
+
+    def matches(m: Dict) -> bool:
+        msg_chat_id = m.get('chat_id', '')
+        is_group = m.get('is_group', False)
+        group_info = m.get('group_info', {})
+
+        # Use sender_phone directly -- Go RPC already resolves LIDs.
+        # For group messages, prefer group_info.sender_phone, fall back
+        # to root sender_phone.
+        if is_group:
+            sender_phone = group_info.get('sender_phone', '') or m.get('sender_phone', '')
+        else:
+            sender_phone = m.get('sender_phone', '')
+
+        # Fallback: extract phone from sender JID if sender_phone absent.
+        if not sender_phone:
+            sender = m.get('sender', '')
+            sender_phone = sender.split('@')[0] if '@' in sender else sender
+
+        # Message type filter (schema field: message_type).
+        if msg_type != 'all' and m.get('message_type') != msg_type:
+            return False
+
+        # Sender filter -- for ``contact`` filter, use actual phone.
+        if sender_filter == 'self':
+            # Self-chat (notes-to-self) only -- must be from me AND in
+            # a chat with myself.
+            if not m.get('is_from_me'):
+                return False
+            chat_id = m.get('chat_id', '')
+            sender = m.get('sender', '')
+            if chat_id != sender:
+                return False
+
+        if sender_filter == 'any_contact':
+            if is_group:
+                return False
+
+        if sender_filter == 'contact':
+            if contact_phone not in sender_phone:
+                return False
+
+        if sender_filter == 'group':
+            if not is_group:
+                return False
+            if msg_chat_id != group_id:
+                return False
+            # Optional: filter by specific sender within group.
+            if sender_number:
+                if sender_number not in sender_phone:
+                    return False
+
+        if sender_filter == 'channel':
+            if not msg_chat_id.endswith('@newsletter'):
+                return False
+            channel_jid = params.get('channel_jid', '')
+            if channel_jid and msg_chat_id != channel_jid:
+                return False
+
+        if sender_filter == 'keywords':
+            text = (m.get('text') or '').lower()
+            if not any(kw in text for kw in keywords):
+                return False
+
+        # Ignore own messages -- but not when filtering for ``self``.
+        if ignore_own and sender_filter != 'self' and m.get('is_from_me'):
+            return False
+
+        is_forwarded = m.get('is_forwarded', False)
+        if forwarded_filter == 'only_forwarded' and not is_forwarded:
+            return False
+        if forwarded_filter == 'ignore_forwarded' and is_forwarded:
+            return False
+
+        logger.debug("[WhatsAppFilter] Matched message from %s", sender_phone)
+        return True
+
+    return matches

package/server/nodes/whatsapp/_handlers.py

@@ -0,0 +1,167 @@
+"""WhatsApp WebSocket handlers — plugin-owned dispatch table.
+
+Self-registered into the central WS dispatcher via
+``register_ws_handlers(WS_HANDLERS)`` from this package's
+``__init__.py``. ``routers/websocket.py`` knows nothing about
+WhatsApp; the message-type strings are wired here so renames /
+additions stay local to the plugin.
+
+Each handler is a thin shim over the underlying RPC client in
+:mod:`._service`. Logic lives in the service module; this module is
+the WS surface.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from fastapi import WebSocket
+
+from ._service import (
+    handle_whatsapp_chat_history as _wa_chat_history,
+    handle_whatsapp_connected_phone as _wa_connected_phone,
+    handle_whatsapp_group_info as _wa_group_info,
+    handle_whatsapp_groups as _wa_groups,
+    handle_whatsapp_newsletters as _wa_newsletters,
+    handle_whatsapp_qr as _wa_qr,
+    handle_whatsapp_restart as _wa_restart,
+    handle_whatsapp_send as _wa_send,
+    handle_whatsapp_start as _wa_start,
+    handle_whatsapp_status as _wa_status,
+    whatsapp_rpc_call as _wa_rpc_call,
+)
+
+
+async def handle_whatsapp_status(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    return await _wa_status()
+
+
+async def handle_whatsapp_connected_phone(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get the connected WhatsApp phone number."""
+    return await _wa_connected_phone()
+
+
+async def handle_whatsapp_qr(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    return await _wa_qr()
+
+
+async def handle_whatsapp_send(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Forward all send params to WhatsApp handler — supports all message types."""
+    return await _wa_send(data)
+
+
+async def handle_whatsapp_start(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    return await _wa_start()
+
+
+async def handle_whatsapp_restart(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    return await _wa_restart()
+
+
+async def handle_whatsapp_groups(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    return await _wa_groups()
+
+
+async def handle_whatsapp_newsletters(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get list of subscribed newsletter channels."""
+    return await _wa_newsletters()
+
+
+async def handle_whatsapp_group_info(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get group participants with resolved phone numbers."""
+    group_id = data.get("group_id", "")
+    return await _wa_group_info(group_id)
+
+
+async def handle_whatsapp_chat_history(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get chat history from WhatsApp history store."""
+    return await _wa_chat_history(data)
+
+
+# ---- Rate-limit RPC passthroughs ----
+
+async def handle_whatsapp_rate_limit_get(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get rate-limit config and current stats."""
+    return await _wa_rpc_call("rate_limit_get", {})
+
+
+async def handle_whatsapp_rate_limit_set(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Update rate-limit configuration."""
+    return await _wa_rpc_call("rate_limit_set", data.get("config", {}))
+
+
+async def handle_whatsapp_rate_limit_stats(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get current rate-limit statistics."""
+    return await _wa_rpc_call("rate_limit_stats", {})
+
+
+async def handle_whatsapp_rate_limit_unpause(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Resume rate limiting after an automatic pause."""
+    return await _wa_rpc_call("rate_limit_unpause", {})
+
+
+# ---- Lightweight RPC passthroughs ----
+
+async def handle_whatsapp_mark_read(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Mark messages as read. Schema: mark_read({message_ids, chat_jid, sender_jid?})."""
+    message_ids = data.get("message_ids", [])
+    chat_jid = data.get("chat_jid", "")
+    if not message_ids or not chat_jid:
+        return {"success": False, "error": "message_ids (array) and chat_jid are required"}
+    params: Dict[str, Any] = {"message_ids": message_ids, "chat_jid": chat_jid}
+    if sender_jid := data.get("sender_jid"):
+        params["sender_jid"] = sender_jid
+    return await _wa_rpc_call("mark_read", params)
+
+
+async def handle_whatsapp_typing(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Send typing indicator. Schema: typing({jid, state: 'composing'|'paused', media?})."""
+    jid = data.get("jid", "")
+    if not jid:
+        return {"success": False, "error": "jid is required"}
+    params: Dict[str, Any] = {"jid": jid, "state": data.get("state", "composing")}
+    if media := data.get("media"):
+        params["media"] = media
+    return await _wa_rpc_call("typing", params)
+
+
+async def handle_whatsapp_presence(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Set online/offline presence. Schema: presence({status: 'available'|'unavailable'})."""
+    return await _wa_rpc_call("presence", {"status": data.get("status", "available")})
+
+
+async def handle_whatsapp_stop(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Graceful WhatsApp shutdown."""
+    return await _wa_rpc_call("stop", {})
+
+
+async def handle_whatsapp_diagnostics(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get WhatsApp diagnostics / debug info."""
+    return await _wa_rpc_call("diagnostics", {})
+
+
+# Dispatch table consumed by ``services.ws_handler_registry`` —
+# ``__init__.py`` registers this dict on package import. Ordering
+# preserved from the legacy ``MESSAGE_HANDLERS`` block in
+# ``routers/websocket.py`` so the wire surface is byte-identical.
+WS_HANDLERS = {
+    "whatsapp_status": handle_whatsapp_status,
+    "whatsapp_connected_phone": handle_whatsapp_connected_phone,
+    "whatsapp_qr": handle_whatsapp_qr,
+    "whatsapp_send": handle_whatsapp_send,
+    "whatsapp_start": handle_whatsapp_start,
+    "whatsapp_restart": handle_whatsapp_restart,
+    "whatsapp_groups": handle_whatsapp_groups,
+    "whatsapp_group_info": handle_whatsapp_group_info,
+    "whatsapp_chat_history": handle_whatsapp_chat_history,
+    "whatsapp_newsletters": handle_whatsapp_newsletters,
+    "whatsapp_rate_limit_get": handle_whatsapp_rate_limit_get,
+    "whatsapp_rate_limit_set": handle_whatsapp_rate_limit_set,
+    "whatsapp_rate_limit_stats": handle_whatsapp_rate_limit_stats,
+    "whatsapp_rate_limit_unpause": handle_whatsapp_rate_limit_unpause,
+    "whatsapp_mark_read": handle_whatsapp_mark_read,
+    "whatsapp_typing": handle_whatsapp_typing,
+    "whatsapp_presence": handle_whatsapp_presence,
+    "whatsapp_stop": handle_whatsapp_stop,
+    "whatsapp_diagnostics": handle_whatsapp_diagnostics,
+}

package/server/nodes/whatsapp/_option_loaders.py

@@ -0,0 +1,68 @@
+"""WhatsApp ``loadOptionsMethod`` loaders.
+
+Wave 11.I, milestone M.1. Each function is registered with
+``services.ws_handler_registry.register_option_loader`` from
+``__init__.py`` so the central ``dispatch_load_options`` picks them
+up without a plugin-specific import.
+
+Adapter shape: turn the existing WS-handler responses
+(``handle_whatsapp_groups`` / ``handle_whatsapp_newsletters`` /
+``handle_whatsapp_group_info``) into the unified ``[{value, label}]``
+list the frontend ``useLoadOptionsQuery`` consumes. The legacy WS
+message types stay live for back-compat.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from ._service import (
+    handle_whatsapp_group_info,
+    handle_whatsapp_groups,
+    handle_whatsapp_newsletters,
+)
+
+
+async def load_groups(params: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """List WhatsApp groups for the ``recipient_type='group'`` selector."""
+    response = await handle_whatsapp_groups()
+    groups = response.get("groups", []) if isinstance(response, dict) else []
+    return [
+        {
+            "value": g.get("group_jid") or g.get("id") or "",
+            "label": g.get("name") or g.get("subject") or g.get("group_jid", ""),
+        }
+        for g in groups
+    ]
+
+
+async def load_channels(params: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """List subscribed newsletter channels for the ``channel_jid`` selector."""
+    response = await handle_whatsapp_newsletters()
+    channels = response.get("newsletters", []) if isinstance(response, dict) else []
+    return [
+        {
+            "value": c.get("channel_jid") or c.get("id") or "",
+            "label": c.get("name") or c.get("channel_jid", ""),
+        }
+        for c in channels
+    ]
+
+
+async def load_group_members(params: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """List members of a specific WhatsApp group for the ``senderNumber``
+    selector. Depends on ``params['group_id']``."""
+    group_id = params.get("group_id") or ""
+    if not group_id:
+        return []
+    response = await handle_whatsapp_group_info(group_id)
+    participants = (
+        response.get("participants", []) if isinstance(response, dict) else []
+    )
+    return [
+        {
+            "value": p.get("phone") or p.get("jid") or "",
+            "label": p.get("name") or p.get("phone") or p.get("jid", ""),
+        }
+        for p in participants
+    ]