Skip to content

Self-improving AI Employees for everyone

feat(temporal): chatTrigger canary rollout (Wave 12 C1 #1)

trohitg850cc9d050af
diff --git a/server/nodes/trigger/chat_trigger/_events.py b/server/nodes/trigger/chat_trigger/_events.py
index cd6dbdb3..ed5c17da 100644
--- a/server/nodes/trigger/chat_trigger/_events.py
+++ b/server/nodes/trigger/chat_trigger/_events.py
@@ -47,12 +47,34 @@ def chat_message_received(event_data: Mapping[str, Any]) -> WorkflowEvent:
# ---- Dispatcher wrapper ----------------------------------------------------
-def dispatch_chat_message_received(event_data: Mapping[str, Any]) -> int:
- """Dispatch an incoming chat message to waiting ``chatTrigger``
- nodes. Returns the count of resolved waiters."""
+async def dispatch_chat_message_received(event_data: Mapping[str, Any]) -> int:
+ """Dispatch an incoming chat message to waiting ``chatTrigger`` nodes.
+
+ Two delivery paths (in priority order):
+
+ 1. **Legacy event_waiter waiters** via :func:`event_waiter.dispatch`
+ (in-process collector/processor; default while
+ ``Settings.event_framework_enabled`` is off).
+ 2. **Temporal-durable listeners** via :func:`services.events.dispatch.emit`
+ (Wave 12 C1 canary). ``emit`` is a no-op pass-through when the
+ feature flag is off, so the legacy path keeps working unchanged.
+
+ Returns the count of legacy waiters resolved (Temporal listeners
+ are signalled asynchronously through Visibility queries and don't
+ show up in this count — that's by design, the chat panel UI only
+ cares about the legacy resolved-count for its "delivered" badge).
+ """
from services import event_waiter
+ from services.events.dispatch import emit
- return event_waiter.dispatch(_LEGACY_EVENT_TYPE, dict(event_data))
+ payload = dict(event_data)
+ resolved = event_waiter.dispatch(_LEGACY_EVENT_TYPE, payload)
+
+ # Temporal-durable fan-out (Wave 12 C1 canary). Always-call;
+ # dispatch.emit is a no-op when the feature flag is off.
+ await emit(chat_message_received(payload), wire_routing_key=_LEGACY_EVENT_TYPE)
+
+ return resolved
__all__ = [
diff --git a/server/routers/websocket.py b/server/routers/websocket.py
index e94d2c85..d87b3071 100644
--- a/server/routers/websocket.py
+++ b/server/routers/websocket.py
@@ -1675,8 +1675,9 @@ async def handle_send_chat_message(data: Dict[str, Any], websocket: WebSocket) -
"session_id": session_id
}
- # Dispatch to chatTrigger waiters
- resolved = dispatch_chat_message_received(event_data)
+ # Dispatch to chatTrigger waiters (legacy event_waiter + Temporal-durable
+ # canary via dispatch.emit; the wrapper is async since Wave 12 C1).
+ resolved = await dispatch_chat_message_received(event_data)
logger.info(f"[ChatMessage] Dispatched message to {resolved} chatTrigger waiter(s)")
diff --git a/server/services/deployment/manager.py b/server/services/deployment/manager.py
index 85feec99..25c2f6eb 100644
--- a/server/services/deployment/manager.py
+++ b/server/services/deployment/manager.py
@@ -29,7 +29,12 @@ logger = get_logger(__name__)
# Settings.event_framework_enabled. When the flag is off the canary set
# is irrelevant; when on, types outside this set stay on the legacy path.
# Expansion path: add types here as each is proven Temporal-durable.
-_CANARY_LISTENER_TRIGGER_TYPES = frozenset(["webhookTrigger"])
+# Each entry requires its producer plugin's _events.py wrapper to call
+# services.events.dispatch.emit so signals reach running listeners.
+_CANARY_LISTENER_TRIGGER_TYPES = frozenset([
+ "webhookTrigger", # shipped 2026-05-14 (C1 canary)
+ "chatTrigger", # shipped 2026-05-14 (C1 rollout #1)
+])
# Listener Temporal workflow type-name. Used both for ``start_workflow``
# and as the Visibility filter for cancellation discovery.
@@ -518,6 +523,21 @@ class DeploymentManager:
"""
return f"trigger-listener-{workflow_id}-{node_id}"
+ @staticmethod
+ def _trigger_kind_for(node_type: str) -> str:
+ """Coarse-grained classification for the ``EventTriggerKind``
+ Search Attribute. Derived from the node_type by stripping the
+ ``Trigger`` / ``Receive`` suffix — same mapping the frontend
+ uses for filter chips on the ops dashboard.
+
+ Examples: ``webhookTrigger`` → ``webhook``, ``chatTrigger`` →
+ ``chat``, ``telegramReceive`` → ``telegram``.
+ """
+ for suffix in ("Trigger", "Receive"):
+ if node_type.endswith(suffix):
+ return node_type[: -len(suffix)]
+ return node_type
+
@staticmethod
async def _canary_listener_enabled_for(node_type: str) -> bool:
"""Whether the C1 canary applies to this trigger type.
@@ -604,7 +624,7 @@ class DeploymentManager:
SearchAttributePair(event_type_key, event_type),
SearchAttributePair(trigger_node_id_key, node_id),
SearchAttributePair(event_workflow_id_key, workflow_id),
- SearchAttributePair(event_trigger_kind_key, "webhook"),
+ SearchAttributePair(event_trigger_kind_key, self._trigger_kind_for(node_type)),
]),
)
diff --git a/server/tests/test_chat_trigger_canary_producer.py b/server/tests/test_chat_trigger_canary_producer.py
new file mode 100644
index 00000000..f2d81436
--- /dev/null
+++ b/server/tests/test_chat_trigger_canary_producer.py
@@ -0,0 +1,118 @@
+"""Wave 12 C1 rollout #1: chatTrigger producer dual-emit invariant.
+
+Locks the contract: ``nodes.trigger.chat_trigger._events.dispatch_chat_message_received``
+must route to BOTH the legacy in-process ``event_waiter.dispatch`` AND
+the Temporal-durable ``services.events.dispatch.emit`` path. Without
+the second call, a canary-enabled chatTrigger deployment would silently
+miss all incoming chat messages — the TriggerListenerWorkflow has no
+other event source.
+
+Same regex-introspection invariant style as
+``tests/test_credential_broadcasts.py`` — source-level assertions
+catch the wire contract drifting without paying the cost of standing
+up Temporal in CI.
+"""
+
+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
+
+# Stub `machina` namespace.
+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
+
+
+_EVENT_WAITER_DISPATCH_PATTERN = re.compile(r"event_waiter\.dispatch\s*\(")
+_EVENTS_EMIT_PATTERN = re.compile(r"\bemit\s*\(")
+
+
+class TestChatTriggerProducerDualEmit:
+ """Producer wrapper emits BOTH legacy and Temporal envelopes."""
+
+ def test_dispatcher_is_async(self):
+ from nodes.trigger.chat_trigger._events import dispatch_chat_message_received
+
+ # async coroutine functions return a coroutine when called.
+ # Both `asyncio.iscoroutinefunction` and `inspect.iscoroutinefunction`
+ # detect this.
+ assert inspect.iscoroutinefunction(dispatch_chat_message_received), (
+ "dispatch_chat_message_received must be async since Wave 12 C1 — "
+ "it awaits services.events.dispatch.emit. Sync callers must "
+ "switch to `await dispatch_chat_message_received(...)`."
+ )
+
+ def test_dispatcher_routes_both_legacy_and_temporal(self):
+ from nodes.trigger.chat_trigger import _events
+
+ src = inspect.getsource(_events.dispatch_chat_message_received)
+
+ # Legacy event_waiter.dispatch path stays for back-compat.
+ assert _EVENT_WAITER_DISPATCH_PATTERN.search(src), (
+ "dispatch_chat_message_received must still call "
+ "event_waiter.dispatch(_LEGACY_EVENT_TYPE, ...) for the "
+ "in-process waiter path. Without it, canary-flag-off "
+ "deployments lose their existing chat dispatch."
+ )
+
+ # Temporal-durable path via dispatch.emit.
+ assert _EVENTS_EMIT_PATTERN.search(src), (
+ "dispatch_chat_message_received must call "
+ "services.events.dispatch.emit(envelope, ...) for the "
+ "Temporal-durable canary path. Without it, the "
+ "TriggerListenerWorkflow receives nothing when the "
+ "event_framework_enabled flag is on."
+ )
+
+ @pytest.mark.asyncio
+ async def test_runtime_dual_emit_calls_both_paths(self, monkeypatch):
+ """Integration smoke: invoke the dispatcher and assert both
+ downstream calls fire. event_framework_enabled=False so emit()
+ no-ops on the Temporal side; the call still happens though."""
+ from nodes.trigger.chat_trigger import _events
+ from services import event_waiter
+ from services.events import dispatch as dispatch_mod
+
+ legacy_calls: List[Dict[str, Any]] = []
+ emit_calls: List[Any] = []
+
+ def fake_dispatch(event_type, data):
+ legacy_calls.append({"event_type": event_type, "data": data})
+ return 0
+
+ async def fake_emit(event, **kwargs):
+ emit_calls.append({"event": event, **kwargs})
+ return event
+
+ monkeypatch.setattr(event_waiter, "dispatch", fake_dispatch)
+ monkeypatch.setattr(dispatch_mod, "emit", fake_emit)
+
+ result = await _events.dispatch_chat_message_received({
+ "message": "hello",
+ "session_id": "sess-1",
+ "timestamp": "2026-05-14T00:00:00",
+ })
+
+ # Legacy returned the resolved count.
+ assert result == 0
+
+ assert len(legacy_calls) == 1
+ assert legacy_calls[0]["event_type"] == "chat_message_received"
+ assert legacy_calls[0]["data"]["message"] == "hello"
+
+ assert len(emit_calls) == 1
+ event = emit_calls[0]["event"]
+ assert event.type == "com.machinaos.chat.message.received"
+ assert event.subject == "sess-1"
+ assert emit_calls[0]["wire_routing_key"] == "chat_message_received"
diff --git a/server/tests/test_deployment_canary_listener.py b/server/tests/test_deployment_canary_listener.py
index 78f5b2fd..7ca52c85 100644
--- a/server/tests/test_deployment_canary_listener.py
+++ b/server/tests/test_deployment_canary_listener.py
@@ -156,6 +156,49 @@ class TestCanaryScope:
result = await DeploymentManager._canary_listener_enabled_for("webhookTrigger")
assert result is True
+ @pytest.mark.asyncio
+ async def test_enabled_for_chat_trigger_when_flag_on(self, monkeypatch):
+ """C1 rollout #1: chatTrigger joined the canary set."""
+ from services.deployment.manager import DeploymentManager
+
+ class _On:
+ event_framework_enabled = True
+
+ import core.config
+ monkeypatch.setattr(core.config, "Settings", lambda: _On())
+
+ result = await DeploymentManager._canary_listener_enabled_for("chatTrigger")
+ assert result is True
+
+
+class TestTriggerKindDerivation:
+ """``EventTriggerKind`` Search Attribute is derived from node_type
+ by stripping the ``Trigger`` / ``Receive`` suffix. Locks the mapping
+ so future trigger types (e.g. ``slackReceive``) get a sensible
+ default kind without per-type code changes in DeploymentManager."""
+
+ def test_strips_trigger_suffix(self):
+ from services.deployment.manager import DeploymentManager
+
+ assert DeploymentManager._trigger_kind_for("webhookTrigger") == "webhook"
+ assert DeploymentManager._trigger_kind_for("chatTrigger") == "chat"
+ assert DeploymentManager._trigger_kind_for("taskTrigger") == "task"
+
+ def test_strips_receive_suffix(self):
+ from services.deployment.manager import DeploymentManager
+
+ assert DeploymentManager._trigger_kind_for("telegramReceive") == "telegram"
+ assert DeploymentManager._trigger_kind_for("whatsappReceive") == "whatsapp"
+ assert DeploymentManager._trigger_kind_for("emailReceive") == "email"
+
+ def test_unknown_suffix_returns_node_type_verbatim(self):
+ from services.deployment.manager import DeploymentManager
+
+ # Defensive fallback — never crashes, just emits whatever the
+ # node_type was. Ops dashboards see the raw value and can
+ # update the chip-mapping when needed.
+ assert DeploymentManager._trigger_kind_for("customListener") == "customListener"
+
# ---------------------------------------------------------------------------
# C1d.3 — _start_canary_listener: deterministic id + USE_EXISTING + search attrs
@@ -247,10 +290,49 @@ class TestStartCanaryListener:
attrs_by_name = {pair.key.name: pair.value for pair in sa}
assert attrs_by_name["EventWorkflowId"] == "wf-xyz"
assert attrs_by_name["TriggerNodeId"] == "wh-1"
+ # EventTriggerKind derived via _trigger_kind_for (strips "Trigger" /
+ # "Receive" suffix) — NOT hardcoded "webhook".
assert attrs_by_name["EventTriggerKind"] == "webhook"
# EventType comes from event_waiter.TRIGGER_REGISTRY['webhookTrigger'].
assert attrs_by_name["EventType"] == "webhook_received"
+ @pytest.mark.asyncio
+ async def test_chat_trigger_uses_chat_kind_in_search_attrs(self, monkeypatch):
+ """C1 rollout #1: starting a chatTrigger listener picks the
+ right EventTriggerKind ('chat', not 'webhook')."""
+ from services.deployment.manager import DeploymentManager
+ from temporalio.common import TypedSearchAttributes
+
+ mgr, _ = _build_manager_with_state(
+ "wf-chat",
+ nodes=[_node("ct-1", "chatTrigger"), _node("agent-1", "aiAgent")],
+ edges=[{"source": "ct-1", "target": "agent-1", "targetHandle": "input-main"}],
+ )
+
+ recorded: List[Dict[str, Any]] = []
+
+ async def fake_start_workflow(workflow_name, **kwargs):
+ recorded.append(kwargs)
+ return MagicMock()
+
+ client = MagicMock()
+ client.start_workflow = fake_start_workflow
+ wrapper = MagicMock()
+ wrapper.client = client
+
+ from core import container as container_mod
+ monkeypatch.setattr(container_mod.container, "temporal_client", lambda: wrapper)
+
+ listener_id = await mgr._start_canary_listener(
+ _node("ct-1", "chatTrigger"), "wf-chat", params={"session_id": "default"}
+ )
+ assert listener_id == "trigger-listener-wf-chat-ct-1"
+
+ sa = recorded[0]["search_attributes"]
+ attrs_by_name = {pair.key.name: pair.value for pair in sa}
+ assert attrs_by_name["EventTriggerKind"] == "chat"
+ assert attrs_by_name["EventType"] == "chat_message_received"
+
@pytest.mark.asyncio
async def test_returns_none_when_temporal_not_connected(self, monkeypatch):
"""Falls through to legacy path; doesn't raise."""