Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
feat(temporal): whatsappReceive canary rollout (Wave 12 C1 #4 — final)
trohitgb4db7da41729
diff --git a/docs-internal/event_framework.md b/docs-internal/event_framework.mdindex 0c6bbf1c..634f7e23 100644--- a/docs-internal/event_framework.md+++ b/docs-internal/event_framework.md@@ -15,7 +15,7 @@ phase plan lives in `~/.claude/plans/properly-fix-the-tech-dreamy-tarjan.md`.| B1-B10 — plugin-owned `_events.py` modules (9 plugin folders) | ✅ shipped (commits `7e4ff7b`, `c4d9428`, `da63d73`, `de8be88`) || B11 — FE handler migration to envelope-aware readers | ⏳ deferred to FE session || C1 canary (webhookTrigger) — `TriggerListenerWorkflow` + Visibility-API registry | ✅ shipped 2026-05-14 (25 tests) |-| C1 rollout — promote remaining event triggers | ⏳ pending |+| C1 rollout (chat / task / telegram / whatsapp) — plugin-self-registered via `canary_registry` | ✅ shipped 2026-05-14 || C2 — Polling triggers as long-lived workflows | ⏳ pending || C3 — APScheduler → Temporal Schedules | ⏳ pending || C4 — Close cross-plugin `_service` reaches (4 sites) | ⏳ pending |diff --git a/server/nodes/whatsapp/__init__.py b/server/nodes/whatsapp/__init__.pyindex 1767cb21..206396e6 100644--- a/server/nodes/whatsapp/__init__.py+++ b/server/nodes/whatsapp/__init__.py@@ -19,6 +19,7 @@ Two self-registrations happen on package import:"""from services._supervisor import register_supervisor+from services.deployment.canary_registry import register_canary_trigger_typefrom services.event_waiter import register_filter_builderfrom services.status_broadcaster import register_service_refreshfrom services.ws_handler_registry import (@@ -65,6 +66,14 @@ register_option_loader("whatsappGroups", load_groups)register_option_loader("whatsappChannels", load_channels)register_option_loader("whatsappGroupMembers", load_group_members)+# Wave 12 C1 rollout #4: opt whatsappReceive into the+# TriggerListenerWorkflow consumer path. Producer side:+# broadcast_whatsapp_message(direction="received", ...) in ._events.py+# fans out via services.events.dispatch.emit; emit() is gated by+# Settings.event_framework_enabled so the legacy path stays default.+# See services/deployment/canary_registry.py.+register_canary_trigger_type("whatsappReceive")+__all__ = ["WhatsAppRuntime","get_whatsapp_runtime",diff --git a/server/nodes/whatsapp/_events.py b/server/nodes/whatsapp/_events.pyindex 32305a23..b3681a0d 100644--- a/server/nodes/whatsapp/_events.py+++ b/server/nodes/whatsapp/_events.py@@ -199,7 +199,14 @@ async def broadcast_whatsapp_message(params: Mapping[str, Any],) -> None:"""Emit a message event (sent or received). Wire-routing key- preserves the legacy ``whatsapp_message_<direction>`` channel."""+ preserves the legacy ``whatsapp_message_<direction>`` channel.++ For inbound (``received``) messages, also fans out via+ :func:`services.events.dispatch.emit` so Wave 12 C1 canary+ :class:`TriggerListenerWorkflow` consumers can pick up the+ envelope (no-op when ``Settings.event_framework_enabled`` is off,+ so the legacy WS path stays default).+ """from services.status_broadcaster import get_status_broadcasterbroadcaster = get_status_broadcaster()@@ -207,21 +214,30 @@ async def broadcast_whatsapp_message(_MESSAGE_SENT_WIRE_KEY if direction == "sent"else _MESSAGE_RECEIVED_WIRE_KEY)+ payload = dict(params)# Legacy raw frame.await broadcaster.broadcast({"type": wire_key,- "data": dict(params),+ "data": payload,})# Typed CloudEvents sibling — same outer wire key (the inner# envelope is what carries the typed contract).- event = whatsapp_message_event(direction, params)+ event = whatsapp_message_event(direction, payload)await broadcaster.broadcast({"type": wire_key,"data": event.model_dump(mode="json"),})+ # Wave 12 C1 rollout #4: Temporal-durable canary fan-out (received+ # only; outbound message events are pure observation, no trigger+ # node consumes them). emit() no-ops when the feature flag is off.+ if direction == "received":+ from services.events.dispatch import emit++ await emit(event, wire_routing_key=wire_key)+async def broadcast_whatsapp_newsletter(verb: Literal["joined", "left", "muted", "live_updated"],diff --git a/server/tests/test_whatsapp_trigger_canary_producer.py b/server/tests/test_whatsapp_trigger_canary_producer.pynew file mode 100644index 00000000..8c7d4106--- /dev/null+++ b/server/tests/test_whatsapp_trigger_canary_producer.py@@ -0,0 +1,157 @@+"""Wave 12 C1 rollout #4: whatsappReceive producer dual-emit invariant.++Locks the contract: ``nodes.whatsapp._events.broadcast_whatsapp_message``+must fan out incoming (``direction="received"``) messages to the+Temporal-durable ``services.events.dispatch.emit`` path so canary+listeners can consume them. Outbound (``direction="sent"``) messages+are pure observation — no trigger node consumes them, so the+``dispatch.emit`` call is gated on direction == "received" inside+the broadcaster.++Same regex-introspection + runtime smoke pattern used for+webhookTrigger / chatTrigger / taskTrigger / telegramReceive+producers in this series.+"""++from __future__ import annotations++import inspect+import re+import sys+import types+from typing import Any, Dict, List+from unittest.mock import AsyncMock, MagicMock++import pytest+++if "machina" not in sys.modules:+ _machina = types.ModuleType("machina")+ _machina.__path__ = []+ sys.modules["machina"] = _machina+ _machina_tcp = types.ModuleType("machina.tcp")+ _machina_tcp.probe_tcp_port = MagicMock(return_value=False)+ sys.modules["machina.tcp"] = _machina_tcp+++_EVENTS_EMIT_PATTERN = re.compile(r"\bemit\s*\(")+_DIRECTION_GUARD_PATTERN = re.compile(r"direction\s*==\s*[\"']received[\"']")+++class TestWhatsappProducerDualEmit:+ """Producer wrapper fans out received messages to the canary path."""++ def test_broadcaster_is_async(self):+ from nodes.whatsapp._events import broadcast_whatsapp_message++ assert inspect.iscoroutinefunction(broadcast_whatsapp_message)++ def test_broadcaster_calls_dispatch_emit_for_received(self):+ from nodes.whatsapp import _events++ src = inspect.getsource(_events.broadcast_whatsapp_message)++ assert _EVENTS_EMIT_PATTERN.search(src), (+ "broadcast_whatsapp_message must call "+ "services.events.dispatch.emit(...) so canary "+ "TriggerListenerWorkflow consumers receive incoming "+ "WhatsApp messages."+ )++ assert _DIRECTION_GUARD_PATTERN.search(src), (+ "broadcast_whatsapp_message must gate the dispatch.emit "+ "call on direction == 'received' — outbound 'sent' events "+ "are pure observation and have no trigger consumers."+ )++ @pytest.mark.asyncio+ async def test_received_message_fires_dispatch_emit(self, monkeypatch):+ from nodes.whatsapp import _events+ from services.events import dispatch as dispatch_mod+ from services import status_broadcaster as sb++ emit_calls: List[Dict[str, Any]] = []++ async def fake_emit(event, **kwargs):+ emit_calls.append({"event": event, **kwargs})+ return event++ broadcaster = MagicMock()+ broadcaster.broadcast = AsyncMock()++ monkeypatch.setattr(sb, "get_status_broadcaster", lambda: broadcaster)+ monkeypatch.setattr(dispatch_mod, "emit", fake_emit)++ await _events.broadcast_whatsapp_message(+ "received",+ {+ "chat_id": "[email protected]",+ "text": "hello",+ "message_id": "abc",+ "from": "+1234567890",+ },+ )++ # WS broadcasts still fire (legacy raw + typed sibling).+ assert broadcaster.broadcast.await_count == 2++ # And the canary path fires exactly once.+ assert len(emit_calls) == 1+ envelope = emit_calls[0]["event"]+ assert envelope.type == "com.machinaos.whatsapp.message.received"+ assert envelope.subject == "[email protected]"+ assert emit_calls[0]["wire_routing_key"] == "whatsapp_message_received"++ @pytest.mark.asyncio+ async def test_sent_message_does_not_fire_dispatch_emit(self, monkeypatch):+ """Outbound message — observation only, no trigger consumer.++ Skipping the canary fan-out here keeps the Visibility query ++ signal load proportional to actual trigger demand. Without the+ guard, every outbound message would query Temporal Visibility+ with zero matches every time.+ """+ from nodes.whatsapp import _events+ from services.events import dispatch as dispatch_mod+ from services import status_broadcaster as sb++ emit_calls: List[Any] = []++ async def fake_emit(event, **kwargs):+ emit_calls.append(event)+ return event++ broadcaster = MagicMock()+ broadcaster.broadcast = AsyncMock()++ monkeypatch.setattr(sb, "get_status_broadcaster", lambda: broadcaster)+ monkeypatch.setattr(dispatch_mod, "emit", fake_emit)++ await _events.broadcast_whatsapp_message(+ "sent",+ {"chat_id": "[email protected]", "text": "hi"},+ )++ # WS broadcasts still fire for the observation channel.+ assert broadcaster.broadcast.await_count == 2++ # But NO canary fan-out (no trigger consumes outbound).+ assert emit_calls == []+++class TestWhatsappPluginSelfRegistersCanary:+ """Importing the whatsapp plugin opts whatsappReceive into the canary."""++ def test_plugin_import_registers_whatsapp_receive(self):+ from services.deployment import canary_registry++ try:+ __import__("nodes.whatsapp")+ except ImportError as exc: # pragma: no cover+ pytest.xfail(f"nodes.whatsapp not importable: {exc}")++ assert canary_registry.is_canary_trigger_type("whatsappReceive"), (+ "Importing nodes.whatsapp should call "+ "register_canary_trigger_type('whatsappReceive') — see "+ "the __init__.py bottom section."+ )