Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
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.pyindex 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.pyindex 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.pyindex 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+@staticmethodasync 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.pynew file mode 100644index 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.pyindex 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.asyncioasync def test_returns_none_when_temporal_not_connected(self, monkeypatch):"""Falls through to legacy path; doesn't raise."""