Skip to content

Self-improving AI Employees for everyone

refactor(plugin-extraction): K -- 4 trigger filter builders move into plugin folders

trohitg969e2a6bb9d8
diff --git a/server/nodes/email/__init__.py b/server/nodes/email/__init__.py
index a08e8176..ed6db336 100644
--- a/server/nodes/email/__init__.py
+++ b/server/nodes/email/__init__.py
@@ -1 +1,11 @@
-"""Plugins for the 'email' palette group. See ../__init__.py for the package layout."""
+"""Plugins for the 'email' palette group.
+
+Self-registers the trigger filter builder for ``emailReceive`` so the
+central ``services/event_waiter.py`` carries no plugin-specific code.
+"""
+
+from services.event_waiter import register_filter_builder
+
+from ._filters import build_filter as build_email_filter
+
+register_filter_builder("emailReceive", build_email_filter)
diff --git a/server/nodes/email/_filters.py b/server/nodes/email/_filters.py
new file mode 100644
index 00000000..28086ae5
--- /dev/null
+++ b/server/nodes/email/_filters.py
@@ -0,0 +1,21 @@
+"""Email event-trigger filter builder (Wave 11.I, milestone K).
+
+Moved verbatim from ``services/event_waiter.build_email_filter``.
+"""
+
+from __future__ import annotations
+
+from typing import Callable, Dict
+
+
+def build_filter(params: Dict) -> Callable[[Dict], bool]:
+ """Build filter for email events (Himalaya IMAP polling)."""
+ folder_filter = params.get('folder', 'INBOX')
+
+ def matches(data: Dict) -> bool:
+ if folder_filter and folder_filter != 'all':
+ if data.get('folder', '') != folder_filter:
+ return False
+ return True
+
+ return matches
diff --git a/server/nodes/email/email_receive.py b/server/nodes/email/email_receive.py
index 40a6af3d..28be37fb 100644
--- a/server/nodes/email/email_receive.py
+++ b/server/nodes/email/email_receive.py
@@ -42,6 +42,10 @@ class EmailReceiveNode(TriggerNode):
group = ("email", "trigger")
description = "Polling trigger for new emails via IMAP"
component_kind = "trigger"
+ # Wave 11.I, milestone K: ``event_type`` ClassVar lets
+ # ``event_waiter._auto_populate_from_plugins`` backfill
+ # TRIGGER_REGISTRY without a hardcoded entry in event_waiter.
+ event_type = "email_received"
handles = (
{"name": "output-main", "kind": "output", "position": "right",
"label": "Output", "role": "main"},
diff --git a/server/nodes/google/__init__.py b/server/nodes/google/__init__.py
index 7a67bcf8..d669fa0c 100644
--- a/server/nodes/google/__init__.py
+++ b/server/nodes/google/__init__.py
@@ -24,13 +24,16 @@ the FastAPI app pick up the plugin's surface without ever importing
this module by name.
"""
+from services.event_waiter import register_filter_builder
from services.status_broadcaster import register_service_refresh
from services.ws_handler_registry import register_router, register_ws_handlers
from . import _router
+from ._filters import build_gmail_filter
from ._handlers import WS_HANDLERS
from ._refresh import refresh_google_status
register_ws_handlers(WS_HANDLERS)
register_router(_router.router, name="google")
register_service_refresh(refresh_google_status)
+register_filter_builder("gmailReceive", build_gmail_filter)
diff --git a/server/nodes/google/_filters.py b/server/nodes/google/_filters.py
new file mode 100644
index 00000000..e613a919
--- /dev/null
+++ b/server/nodes/google/_filters.py
@@ -0,0 +1,25 @@
+"""Gmail event-trigger filter builder (Wave 11.I, milestone K).
+
+Moved verbatim from ``services/event_waiter.build_gmail_filter``.
+``filter_query`` is applied at the Gmail API level during polling
+(see :mod:`._polling`); this filter only checks labels for events
+already on the bus.
+"""
+
+from __future__ import annotations
+
+from typing import Callable, Dict
+
+
+def build_gmail_filter(params: Dict) -> Callable[[Dict], bool]:
+ """Build filter function for Gmail email events."""
+ label_filter = params.get('label_filter', 'INBOX')
+
+ def matches(data: Dict) -> bool:
+ if label_filter and label_filter != 'all':
+ labels = data.get('labels', [])
+ if label_filter not in labels:
+ return False
+ return True
+
+ return matches
diff --git a/server/nodes/twitter/__init__.py b/server/nodes/twitter/__init__.py
index 42ab274d..783134cc 100644
--- a/server/nodes/twitter/__init__.py
+++ b/server/nodes/twitter/__init__.py
@@ -18,18 +18,21 @@ FastAPI app pick up the plugin's surface without ever importing this
module by name.
"""
+from services.event_waiter import register_filter_builder
from services.status_broadcaster import register_service_refresh
from services.ws_handler_registry import register_router, register_ws_handlers
from . import _router
+from ._filters import build_filter as build_twitter_filter
from ._handlers import WS_HANDLERS
from ._refresh import refresh_twitter_status
# WebSocket handlers (3 message types) and the OAuth-callback HTTP
# router self-register so ``routers/websocket.py`` and ``main.py``
# stay free of per-plugin imports. Plus the service-status refresh
-# callback (Wave 11.I, milestone J) -- the broadcaster fans out to
-# this on lifespan startup instead of hardcoding the call.
+# callback (Wave 11.I, milestone J) and the trigger filter builder
+# (milestone K).
register_ws_handlers(WS_HANDLERS)
register_router(_router.router, name="twitter")
register_service_refresh(refresh_twitter_status)
+register_filter_builder("twitterReceive", build_twitter_filter)
diff --git a/server/nodes/twitter/_filters.py b/server/nodes/twitter/_filters.py
new file mode 100644
index 00000000..27f7e902
--- /dev/null
+++ b/server/nodes/twitter/_filters.py
@@ -0,0 +1,37 @@
+"""Twitter event-trigger filter builder (Wave 11.I, milestone K).
+
+Moved verbatim from ``services/event_waiter.build_twitter_filter``.
+"""
+
+from __future__ import annotations
+
+from typing import Callable, Dict
+
+
+def build_filter(params: Dict) -> Callable[[Dict], bool]:
+ """Build filter function for Twitter events.
+
+ Filters by:
+
+ - ``trigger_type`` -- ``mentions`` / ``search`` / ``user_timeline``
+ - ``search_query`` -- search query for ``search``
+ - ``user_id`` -- user ID for ``user_timeline``
+ """
+ trigger_type = params.get('trigger_type', 'mentions')
+ search_query = params.get('search_query', '')
+ user_id = params.get('user_id', '')
+
+ def matches(data: Dict) -> bool:
+ event_type = data.get('trigger_type', '')
+ if trigger_type != 'all' and event_type != trigger_type:
+ return False
+ if trigger_type == 'search' and search_query:
+ event_query = data.get('query', '')
+ if search_query.lower() not in event_query.lower():
+ return False
+ if trigger_type == 'user_timeline' and user_id:
+ if data.get('user_id') != user_id:
+ return False
+ return True
+
+ return matches
diff --git a/server/nodes/twitter/twitter_receive.py b/server/nodes/twitter/twitter_receive.py
index ef1fc0de..0f77e56f 100644
--- a/server/nodes/twitter/twitter_receive.py
+++ b/server/nodes/twitter/twitter_receive.py
@@ -39,6 +39,10 @@ class TwitterReceiveNode(TriggerNode):
group = ("social", "trigger")
description = "Trigger workflow on Twitter mentions, search results, or timeline updates (polling-based)"
component_kind = "trigger"
+ # Wave 11.I, milestone K: ``event_type`` ClassVar lets
+ # ``event_waiter._auto_populate_from_plugins`` backfill
+ # TRIGGER_REGISTRY without a hardcoded entry in event_waiter.
+ event_type = "twitter_event_received"
handles = (
{"name": "output-main", "kind": "output", "position": "right",
"label": "Output", "role": "main"},
diff --git a/server/nodes/whatsapp/__init__.py b/server/nodes/whatsapp/__init__.py
index 5e2c1b6e..ad70a42c 100644
--- a/server/nodes/whatsapp/__init__.py
+++ b/server/nodes/whatsapp/__init__.py
@@ -19,9 +19,11 @@ Two self-registrations happen on package import:
"""
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_ws_handlers
+from ._filters import build_filter as build_whatsapp_filter
from ._handlers import WS_HANDLERS
from ._refresh import refresh_whatsapp_status
from ._runtime import WhatsAppRuntime, get_whatsapp_runtime
@@ -40,6 +42,11 @@ register_ws_handlers(WS_HANDLERS)
# 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)
+
__all__ = [
"WhatsAppRuntime",
"get_whatsapp_runtime",
diff --git a/server/nodes/whatsapp/_filters.py b/server/nodes/whatsapp/_filters.py
new file mode 100644
index 00000000..6ced9feb
--- /dev/null
+++ b/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
diff --git a/server/services/event_waiter.py b/server/services/event_waiter.py
index 11c140b8..f8928cc8 100644
--- a/server/services/event_waiter.py
+++ b/server/services/event_waiter.py
@@ -85,16 +85,12 @@ class TriggerConfig:
# Registry of supported trigger types (event-based triggers only)
# Note: cronScheduler is NOT an event-based trigger - it uses APScheduler directly
TRIGGER_REGISTRY: Dict[str, TriggerConfig] = {
+ # Framework-level triggers — not owned by any plugin domain.
'start': TriggerConfig(
node_type='start',
event_type='deploy_triggered',
display_name='Deploy Start'
),
- 'whatsappReceive': TriggerConfig(
- node_type='whatsappReceive',
- event_type='whatsapp_message_received',
- display_name='WhatsApp Message'
- ),
'webhookTrigger': TriggerConfig(
node_type='webhookTrigger',
event_type='webhook_received',
@@ -110,24 +106,21 @@ TRIGGER_REGISTRY: Dict[str, TriggerConfig] = {
event_type='task_completed',
display_name='Task Completed'
),
- 'twitterReceive': TriggerConfig(
- node_type='twitterReceive',
- event_type='twitter_event_received',
- display_name='Twitter Event'
- ),
+ # Pre-existing type-name mismatch — the plugin class is
+ # ``googleGmailReceive`` but downstream callers (deployment
+ # manager, this registry) key by ``gmailReceive``. Auto-populate
+ # would key by the class type, so an alias entry stays here until
+ # the gmail plugin renames its type.
'gmailReceive': TriggerConfig(
node_type='gmailReceive',
event_type='gmail_email_received',
display_name='Gmail Email'
),
- # 'telegramReceive' moved to nodes/telegram/ — backfilled here from
- # the plugin's ``event_type`` class attribute via
- # ``_auto_populate_from_plugins`` on first access.
- 'emailReceive': TriggerConfig(
- node_type='emailReceive',
- event_type='email_received',
- display_name='Email'
- ),
+ # Plugin-owned trigger entries (whatsappReceive, twitterReceive,
+ # telegramReceive, emailReceive) live in their plugin folders'
+ # ``_filters.py`` and are backfilled here from each plugin's
+ # ``event_type`` ClassVar via ``_auto_populate_from_plugins``
+ # (Wave 11.I, milestone K).
# Future triggers - just add to registry:
# 'mqttTrigger': TriggerConfig('mqttTrigger', 'mqtt_message', 'MQTT Message'),
}
@@ -213,126 +206,6 @@ def get_trigger_config(node_type: str) -> Optional[TriggerConfig]:
# FILTER BUILDERS - One per trigger type
# =============================================================================
-def build_whatsapp_filter(params: Dict) -> Callable[[Dict], bool]:
- """Build filter function for WhatsApp messages.
-
- Based on Go RPC handleIncomingMessage() event fields (service.go):
- - message_id: string - unique message ID
- - sender: string - Sender JID (may be LID for groups)
- - sender_phone: string - RESOLVED phone number (LID already resolved by Go RPC!)
- - chat_id: string - Chat JID (same as sender for DMs, group JID for groups)
- - timestamp: time - message timestamp
- - is_from_me: boolean - true if sent by connected account
- - is_group: boolean - true if message is in a group chat
- - message_type: string - text, image, video, audio, document, sticker, location, contact, contacts
- - text: string - text content (for text messages)
- - is_forwarded: boolean - true if message is forwarded
- - forwarding_score: int - forwarding count
- - group_info: object - present for group messages:
- - group_jid: string
- - sender_jid: string
- - sender_phone: string - RESOLVED phone number
- - sender_name: string - push name if available
-
- Note: The Go RPC already resolves LIDs to phone numbers before sending the event.
- The sender_phone field contains the resolved phone number - no manual LID resolution needed!
- """
- # Snake_case throughout — matches plugin Params (no camelCase aliases).
- 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(f"[WhatsAppFilter] Built: type={msg_type}, filter={sender_filter}, group_id='{group_id}', forwarded={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 to phone numbers!
- # 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 not available
- 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 number
- if sender_filter == 'self':
- # Only accept messages in self-chat (notes to self)
- # Must be from me AND in a chat with myself (not replies to others)
- if not m.get('is_from_me'):
- return False
- # Check chat_id matches sender (self-chat)
- chat_id = m.get('chat_id', '')
- sender = m.get('sender', '')
- if chat_id != sender:
- return False
-
- if sender_filter == 'any_contact':
- # Only accept non-group messages (individual/contact messages)
- if is_group:
- return False
-
- if sender_filter == 'contact':
- if contact_phone not in sender_phone:
- return False
-
- if sender_filter == 'group':
- # For group filter, check if message is from that group
- if not is_group:
- return False
- if msg_chat_id != group_id:
- return False
- # Optional: filter by specific sender within group using resolved phone number
- if sender_number:
- if sender_number not in sender_phone:
- return False
-
- if sender_filter == 'channel':
- # Only accept messages from newsletter channels (chat_id ends with @newsletter)
- if not msg_chat_id.endswith('@newsletter'):
- return False
- # If specific channel JID provided, match exactly
- 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 (schema field: is_from_me) - but not when filtering for 'self'
- if ignore_own and sender_filter != 'self' and m.get('is_from_me'):
- return False
-
- # Forwarded message filter (schema field: is_forwarded)
- 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(f"[WhatsAppFilter] Matched message from {sender_phone}")
- return True
-
- return matches
-
-
def build_webhook_filter(params: Dict) -> Callable[[Dict], bool]:
"""Build filter function for webhook requests.
@@ -425,94 +298,19 @@ def build_task_completed_filter(params: Dict) -> Callable[[Dict], bool]:
return matches
-def build_twitter_filter(params: Dict) -> Callable[[Dict], bool]:
- """Build filter function for Twitter events.
-
- Filters by:
- - trigger_type: 'mentions', 'search', 'user_timeline'
- - search_query: Search query for 'search' trigger type
- - user_id: User ID for 'user_timeline' trigger type
-
- Args:
- params: Node parameters
-
- Returns:
- Filter function that checks if event matches criteria
- """
- trigger_type = params.get('trigger_type', 'mentions')
- search_query = params.get('search_query', '')
- user_id = params.get('user_id', '')
-
- def matches(data: Dict) -> bool:
- event_type = data.get('trigger_type', '')
- if trigger_type != 'all' and event_type != trigger_type:
- return False
- if trigger_type == 'search' and search_query:
- # Check if search query matches
- event_query = data.get('query', '')
- if search_query.lower() not in event_query.lower():
- return False
- if trigger_type == 'user_timeline' and user_id:
- if data.get('user_id') != user_id:
- return False
- return True
-
- return matches
-
-
-def build_gmail_filter(params: Dict) -> Callable[[Dict], bool]:
- """Build filter function for Gmail email events.
-
- Filters by label to ensure the event matches the trigger's label filter.
- The filter_query is applied at the Gmail API level during polling,
- so this filter only checks labels for events dispatched via event_waiter.
-
- Args:
- params: Node parameters with 'label_filter' field
-
- Returns:
- Filter function that checks if event labels match
- """
- label_filter = params.get('label_filter', 'INBOX')
-
- def matches(data: Dict) -> bool:
- if label_filter and label_filter != 'all':
- labels = data.get('labels', [])
- if label_filter not in labels:
- return False
- return True
-
- return matches
-
-
-def build_email_filter(params: Dict) -> Callable[[Dict], bool]:
- """Build filter for email events (Himalaya IMAP polling)."""
- folder_filter = params.get('folder', 'INBOX')
- filter_query = params.get('filter_query', '')
-
- def matches(data: Dict) -> bool:
- if folder_filter and folder_filter != 'all':
- if data.get('folder', '') != folder_filter:
- return False
- return True
-
- return matches
-
-
# Registry of filter builders per trigger type. Plugin packages
# (nodes/<group>/) call :func:`register_filter_builder` from their
# package ``__init__.py`` to publish per-trigger filters without this
-# module needing to import them. The hardcoded entries below are core
-# triggers that don't yet live in their own plugin folder; once they
-# do, this dict shrinks to ``{}`` and everything is registry-driven.
+# module needing to import them. The hardcoded entries below are
+# **framework-level** triggers (webhook + chat + delegated-task) --
+# they don't belong to any one plugin domain and intentionally stay
+# here. The plugin entries (whatsappReceive, twitterReceive,
+# gmailReceive, emailReceive) live in their plugin folders'
+# ``_filters.py`` and self-register at import time.
FILTER_BUILDERS: Dict[str, Callable[[Dict], Callable[[Dict], bool]]] = {
- 'whatsappReceive': build_whatsapp_filter,
'webhookTrigger': build_webhook_filter,
'chatTrigger': build_chat_filter,
'taskTrigger': build_task_completed_filter,
- 'twitterReceive': build_twitter_filter,
- 'gmailReceive': build_gmail_filter,
- 'emailReceive': build_email_filter,
}
from services.plugin.registry import IdempotentRegistry as _IdempotentRegistry # noqa: E402