Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
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__.pyindex 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.pynew file mode 100644index 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 matchesdiff --git a/server/nodes/email/email_receive.py b/server/nodes/email/email_receive.pyindex 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__.pyindex 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 importingthis module by name."""+from services.event_waiter import register_filter_builderfrom services.status_broadcaster import register_service_refreshfrom services.ws_handler_registry import register_router, register_ws_handlersfrom . import _router+from ._filters import build_gmail_filterfrom ._handlers import WS_HANDLERSfrom ._refresh import refresh_google_statusregister_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.pynew file mode 100644index 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 matchesdiff --git a/server/nodes/twitter/__init__.py b/server/nodes/twitter/__init__.pyindex 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 thismodule by name."""+from services.event_waiter import register_filter_builderfrom services.status_broadcaster import register_service_refreshfrom services.ws_handler_registry import register_router, register_ws_handlersfrom . import _router+from ._filters import build_filter as build_twitter_filterfrom ._handlers import WS_HANDLERSfrom ._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.pynew file mode 100644index 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 matchesdiff --git a/server/nodes/twitter/twitter_receive.py b/server/nodes/twitter/twitter_receive.pyindex 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__.pyindex 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_builderfrom services.status_broadcaster import register_service_refreshfrom services.ws_handler_registry import register_ws_handlers+from ._filters import build_filter as build_whatsapp_filterfrom ._handlers import WS_HANDLERSfrom ._refresh import refresh_whatsapp_statusfrom ._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.pynew file mode 100644index 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 matchesdiff --git a/server/services/event_waiter.py b/server/services/event_waiter.pyindex 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 directlyTRIGGER_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