Skip to content

Self-improving AI Employees for everyone

feat(temporal): whatsappReceive canary rollout (Wave 12 C1 #4 — final)

trohitgb4db7da41729
diff --git a/docs-internal/event_framework.md b/docs-internal/event_framework.md
index 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__.py
index 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_type
from services.event_waiter import register_filter_builder
from services.status_broadcaster import register_service_refresh
from 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.py
index 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_broadcaster
broadcaster = 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.py
new file mode 100644
index 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."
+ )