Skip to content

Self-improving AI Employees for everyone

refactor(events): Wave 12 B4-B10 — drain remaining plugin-named callsites into _events.py

trohitgde8be88f696f
diff --git a/server/nodes/agent/_events.py b/server/nodes/agent/_events.py
new file mode 100644
index 00000000..1346e95e
--- /dev/null
+++ b/server/nodes/agent/_events.py
@@ -0,0 +1,123 @@
+"""Wave 12 B8: CloudEvents broadcaster wrappers for agent task delegation.
+
+Plugin-folder-owned wrappers around the cross-cutting
+``WorkflowEvent.task_completed`` factory (cross-cutting factory itself
+stays in ``services/events/envelope.py`` per RFC §6.4 — it's
+parametrised by ``task_id`` + ``agent`` + ``status`` and uniformly
+applies to every delegated agent task, not single-plugin shape).
+
+What lives here vs the central factory:
+ - Central ``WorkflowEvent.task_completed(task_id, status, agent, data)``
+ factory STAYS in services/events/envelope.py (cross-cutting).
+ - The broadcaster *wrappers* below live with the agent plugin folder
+ so the 3 callsites in ``services/handlers/tools.py`` (the
+ fire-and-forget delegation dispatcher) import from
+ ``nodes.agent._events`` rather than building the wire frame
+ inline.
+
+Wire-routing key ``"task_completed"`` is preserved — the
+``taskTrigger`` plugin filter still subscribes on this string. The
+inner envelope carries the spec-compliant ``com.machinaos.agent.task.{
+succeeded, failed}`` type.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Mapping, Optional
+
+
+# Legacy wire-routing key. The ``taskTrigger`` plugin filters by this
+# string today (see ``services/event_waiter.py:TRIGGER_REGISTRY``).
+_LEGACY_EVENT_TYPE = "task_completed"
+
+
+async def broadcast_agent_task_completed(
+ *,
+ task_id: str,
+ agent_name: str,
+ agent_node_id: str,
+ parent_node_id: str,
+ workflow_id: Optional[str] = None,
+ result: Optional[str] = None,
+) -> None:
+ """Broadcast a delegated agent task completing successfully.
+
+ Replaces inline ``broadcaster.send_custom_event('task_completed',
+ {...})`` calls in ``services/handlers/tools.py``. Builds the
+ payload exactly as the consumer (taskTrigger filter) expects.
+ """
+ await _broadcast_task_event(
+ task_id=task_id,
+ status="completed",
+ agent_name=agent_name,
+ agent_node_id=agent_node_id,
+ parent_node_id=parent_node_id,
+ workflow_id=workflow_id,
+ result=result,
+ )
+
+
+async def broadcast_agent_task_failed(
+ *,
+ task_id: str,
+ agent_name: str,
+ agent_node_id: str,
+ parent_node_id: str,
+ workflow_id: Optional[str] = None,
+ error: str,
+) -> None:
+ """Broadcast a delegated agent task failing.
+
+ Replaces inline ``broadcaster.send_custom_event('task_completed',
+ {status: 'error', ...})`` calls in
+ ``services/handlers/tools.py``.
+ """
+ await _broadcast_task_event(
+ task_id=task_id,
+ status="error",
+ agent_name=agent_name,
+ agent_node_id=agent_node_id,
+ parent_node_id=parent_node_id,
+ workflow_id=workflow_id,
+ error=error,
+ )
+
+
+async def _broadcast_task_event(
+ *,
+ task_id: str,
+ status: str, # "completed" | "error"
+ agent_name: str,
+ agent_node_id: str,
+ parent_node_id: str,
+ workflow_id: Optional[str] = None,
+ result: Optional[str] = None,
+ error: Optional[str] = None,
+) -> None:
+ """Internal helper. Builds the legacy raw-dict payload shape the
+ taskTrigger filter expects, then routes through
+ ``send_custom_event`` (which both broadcasts on the WS + dispatches
+ to event_waiter)."""
+ from services.status_broadcaster import get_status_broadcaster
+
+ payload: dict[str, Any] = {
+ "task_id": task_id,
+ "status": status,
+ "agent_name": agent_name,
+ "agent_node_id": agent_node_id,
+ "parent_node_id": parent_node_id,
+ "workflow_id": workflow_id,
+ }
+ if status == "completed" and result is not None:
+ payload["result"] = result
+ elif status == "error" and error is not None:
+ payload["error"] = error
+
+ broadcaster = get_status_broadcaster()
+ await broadcaster.send_custom_event(_LEGACY_EVENT_TYPE, payload)
+
+
+__all__ = [
+ "broadcast_agent_task_completed",
+ "broadcast_agent_task_failed",
+]
diff --git a/server/nodes/email/__init__.py b/server/nodes/email/__init__.py
index ed6db336..09451fbb 100644
--- a/server/nodes/email/__init__.py
+++ b/server/nodes/email/__init__.py
@@ -6,6 +6,7 @@ central ``services/event_waiter.py`` carries no plugin-specific code.
from services.event_waiter import register_filter_builder
+from ._events import dispatch_email_received # noqa: F401 — re-export
from ._filters import build_filter as build_email_filter
register_filter_builder("emailReceive", build_email_filter)
diff --git a/server/nodes/email/_events.py b/server/nodes/email/_events.py
new file mode 100644
index 00000000..2b2eea21
--- /dev/null
+++ b/server/nodes/email/_events.py
@@ -0,0 +1,64 @@
+"""Wave 12 B4: CloudEvents factories + broadcaster wrappers for email.
+
+Plugin-specific event emission — replaces:
+ - ``event_waiter.dispatch("email_received", email_data)`` in
+ ``email_receive/__init__.py``
+
+Per RFC plugin_authoring_rfc.md §6.4: plugin-specific factories live in
+the plugin folder.
+
+Legacy ``event_type`` (``"email_received"``) is preserved on the
+dispatch path so the ``emailReceive`` trigger node's ``event_type``
+ClassVar still matches without a coordinated registry-side rename
+(Phase B11 / C1 will swap to the typed
+``com.machinaos.email.message.received`` form together).
+"""
+
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from services.events.envelope import WorkflowEvent
+
+
+# Legacy event_type the event_waiter dispatches by; trigger nodes
+# subscribe on this string (matches ``EmailReceiveNode.event_type``).
+_LEGACY_EVENT_TYPE = "email_received"
+
+
+# ---- Typed factory ---------------------------------------------------------
+
+
+def email_message_received(email_data: Mapping[str, Any]) -> WorkflowEvent:
+ """Incoming email envelope. ``subject`` is the ``message_id`` so
+ consumers can dedup and correlate (subject of the MAIL message
+ itself goes in ``data.subject``)."""
+ payload = dict(email_data)
+ message_id = payload.get("message_id") or payload.get("id")
+ return WorkflowEvent(
+ source="machinaos://nodes/email",
+ type="com.machinaos.email.message.received",
+ subject=str(message_id) if message_id else None,
+ data=payload,
+ )
+
+
+# ---- Dispatcher wrapper ----------------------------------------------------
+
+
+def dispatch_email_received(email_data: Mapping[str, Any]) -> int:
+ """Dispatch an incoming email to waiting ``emailReceive`` trigger
+ nodes. Returns the count of resolved waiters.
+
+ Replaces the direct ``event_waiter.dispatch("email_received", ...)``
+ call in ``email_receive/__init__.py``.
+ """
+ from services import event_waiter
+
+ return event_waiter.dispatch(_LEGACY_EVENT_TYPE, dict(email_data))
+
+
+__all__ = [
+ "dispatch_email_received",
+ "email_message_received",
+]
diff --git a/server/nodes/email/email_receive/__init__.py b/server/nodes/email/email_receive/__init__.py
index 14313d35..3e637caa 100644
--- a/server/nodes/email/email_receive/__init__.py
+++ b/server/nodes/email/email_receive/__init__.py
@@ -119,7 +119,6 @@ class EmailReceiveNode(PollingTriggerNode):
from datetime import datetime
from .._service import get_email_service
from services.status_broadcaster import get_status_broadcaster
- from services import event_waiter
start_time = time.time()
raw_params = parameters
@@ -160,7 +159,10 @@ class EmailReceiveNode(PollingTriggerNode):
poll["folder"],
)
- event_waiter.dispatch("email_received", email_data)
+ # Wave 12 B4: route through plugin _events.py wrapper.
+ from nodes.email import dispatch_email_received
+
+ dispatch_email_received(email_data)
return {
"success": True, "node_id": node_id, "node_type": self.type,
"result": email_data,
diff --git a/server/nodes/google/__init__.py b/server/nodes/google/__init__.py
index 3202267a..7207b20f 100644
--- a/server/nodes/google/__init__.py
+++ b/server/nodes/google/__init__.py
@@ -34,6 +34,7 @@ from services.ws_handler_registry import (
)
from . import _router
+from ._events import dispatch_gmail_received # noqa: F401 — re-export
from ._filters import build_gmail_filter
from ._handlers import WS_HANDLERS
from ._option_loaders import (
diff --git a/server/nodes/google/_events.py b/server/nodes/google/_events.py
new file mode 100644
index 00000000..b04882db
--- /dev/null
+++ b/server/nodes/google/_events.py
@@ -0,0 +1,63 @@
+"""Wave 12 B5: CloudEvents factories + broadcaster wrappers for google.
+
+Plugin-specific event emission — replaces:
+ - ``event_waiter.dispatch("gmail_email_received", email_data)`` in
+ ``gmail_receive/__init__.py``.
+
+OAuth completion broadcasts route through the cross-cutting
+``StatusBroadcaster.broadcast_credential_event("credential.oauth.connected", ...)``
+path (RFC §6.4 cross-cutting tier) — NOT a plugin-named broadcast.
+No migration needed here for that flow.
+
+Per RFC plugin_authoring_rfc.md §6.4: plugin-specific factories live
+in the plugin folder.
+
+Legacy ``event_type`` (``"gmail_email_received"``) is preserved so
+the ``gmailReceive`` trigger node's ``event_type`` ClassVar still
+matches without a coordinated registry-side rename.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from services.events.envelope import WorkflowEvent
+
+
+# Legacy event_type the event_waiter dispatches by; trigger nodes
+# subscribe on this string (matches ``GmailReceiveNode.event_type``).
+_LEGACY_EVENT_TYPE = "gmail_email_received"
+
+
+# ---- Typed factory ---------------------------------------------------------
+
+
+def gmail_message_received(email_data: Mapping[str, Any]) -> WorkflowEvent:
+ """Incoming Gmail message envelope. ``subject`` is the Gmail
+ message_id (correlation key for the consumer-side ``markAsRead``
+ + dedup paths)."""
+ payload = dict(email_data)
+ message_id = payload.get("message_id") or payload.get("id")
+ return WorkflowEvent(
+ source="machinaos://nodes/google",
+ type="com.machinaos.gmail.message.received",
+ subject=str(message_id) if message_id else None,
+ data=payload,
+ )
+
+
+# ---- Dispatcher wrapper ----------------------------------------------------
+
+
+def dispatch_gmail_received(email_data: Mapping[str, Any]) -> int:
+ """Dispatch an incoming Gmail message to waiting ``gmailReceive``
+ trigger nodes. Returns the count of resolved waiters."""
+ from services import event_waiter
+
+ return event_waiter.dispatch(_LEGACY_EVENT_TYPE, dict(email_data))
+
+
+__all__ = [
+ "dispatch_gmail_received",
+ "gmail_message_received",
+]
diff --git a/server/nodes/google/gmail_receive/__init__.py b/server/nodes/google/gmail_receive/__init__.py
index 6b798e5b..7a697b33 100644
--- a/server/nodes/google/gmail_receive/__init__.py
+++ b/server/nodes/google/gmail_receive/__init__.py
@@ -115,7 +115,6 @@ class GmailReceiveNode(PollingTriggerNode):
context: NodeContext,
) -> Dict[str, Any]:
"""Polling loop: baseline existing IDs, sleep, fetch new ones, dispatch."""
- from services import event_waiter
from services.status_broadcaster import get_status_broadcaster
start_time = time.time()
@@ -170,7 +169,10 @@ class GmailReceiveNode(PollingTriggerNode):
"gmail", node_id, "receive", 1,
{"workflow_id": context.workflow_id, "session_id": context.session_id},
)
- event_waiter.dispatch("gmail_email_received", email_data)
+ # Wave 12 B5: route through plugin _events.py wrapper.
+ from nodes.google import dispatch_gmail_received
+
+ dispatch_gmail_received(email_data)
logger.info(
f"[GmailReceive] New email: {email_data.get('subject', 'no subject')}",
)
diff --git a/server/nodes/tool/agent_builder/__init__.py b/server/nodes/tool/agent_builder/__init__.py
index 7ac6ff10..1ff6a1bc 100644
--- a/server/nodes/tool/agent_builder/__init__.py
+++ b/server/nodes/tool/agent_builder/__init__.py
@@ -19,8 +19,8 @@ The five operations are pure canvas mutations:
* ``create_workflow`` -- persist a fresh empty workflow + return its
workflow_id.
-Each mutation pushes a ``workflow_ops_apply`` event via
-``status_broadcaster.send_custom_event`` so the live canvas updates.
+Each mutation pushes a ``workflow_ops_apply`` event via the plugin's
+``_events.broadcast_workflow_ops`` wrapper so the live canvas updates.
LangGraph binds tools at graph compile time, so a mutation made
mid-run does NOT add a callable tool to the current run; the
agent's NEXT invocation rediscovers it. Each summary string ends
@@ -70,15 +70,19 @@ _SKILLS_DIR = Path(__file__).resolve().parents[2] / "skills"
async def _broadcast(workflow_id: Optional[str], caller_id: str, ops: List[Dict[str, Any]]) -> None:
- """Push a workflow_ops_apply event so the live canvas updates."""
+ """Push a workflow_ops_apply event so the live canvas updates.
+
+ Wave 12 B10: routes through plugin _events.py wrapper.
+ """
if not ops:
return
try:
- from services.status_broadcaster import get_status_broadcaster
- broadcaster = get_status_broadcaster()
- await broadcaster.send_custom_event(
- "workflow_ops_apply",
- {"workflow_id": workflow_id, "caller_node_id": caller_id, "operations": ops},
+ from ._events import broadcast_workflow_ops
+
+ await broadcast_workflow_ops(
+ workflow_id=workflow_id,
+ caller_node_id=caller_id,
+ operations=ops,
)
logger.info(
"[agentBuilder] broadcast workflow_ops_apply: workflow_id=%s "
diff --git a/server/nodes/tool/agent_builder/_events.py b/server/nodes/tool/agent_builder/_events.py
new file mode 100644
index 00000000..5e6400cc
--- /dev/null
+++ b/server/nodes/tool/agent_builder/_events.py
@@ -0,0 +1,89 @@
+"""Wave 12 B10: CloudEvents factory + broadcaster wrapper for agent_builder.
+
+Plugin-specific event emission — replaces the inline
+``broadcaster.send_custom_event("workflow_ops_apply", {...})`` call in
+``agent_builder/__init__.py:_broadcast``.
+
+The agent_builder canvas-mutation broadcast carries a flat shape
+(``{workflow_id, caller_node_id, operations}``) consumed by the
+frontend's ``useWorkflowOpsListener`` hook directly (NOT via the
+typed-envelope path). Per the existing X4-allowlist rationale, the
+WIRE format stays flat for FE back-compat; the typed envelope is
+constructed for audit/future use only.
+
+Per RFC plugin_authoring_rfc.md §6.4: plugin-specific factories live
+in the plugin folder.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from services.events.envelope import WorkflowEvent
+
+
+# Legacy wire-routing key consumed by ``client/src/hooks/useWorkflowOpsListener``.
+_LEGACY_EVENT_TYPE = "workflow_ops_apply"
+
+
+# ---- Typed factory ---------------------------------------------------------
+
+
+def workflow_ops_applied(
+ *,
+ workflow_id: Optional[str],
+ caller_node_id: str,
+ operations: List[Dict[str, Any]],
+) -> WorkflowEvent:
+ """Canvas-mutation envelope. ``subject`` is the caller node id so
+ consumers can route per-builder."""
+ return WorkflowEvent(
+ source="machinaos://nodes/agent_builder",
+ type="com.machinaos.workflow.ops.applied",
+ subject=caller_node_id,
+ workflow_id=workflow_id,
+ data={
+ "workflow_id": workflow_id,
+ "caller_node_id": caller_node_id,
+ "operations": list(operations),
+ },
+ )
+
+
+# ---- Broadcaster wrapper ---------------------------------------------------
+
+
+async def broadcast_workflow_ops(
+ *,
+ workflow_id: Optional[str],
+ caller_node_id: str,
+ operations: List[Dict[str, Any]],
+) -> None:
+ """Emit a workflow_ops_apply event. Routes through
+ ``broadcaster.send_custom_event`` (raw flat payload for FE
+ back-compat; envelope constructed for future audit use).
+ """
+ if not operations:
+ return
+ from services.status_broadcaster import get_status_broadcaster
+
+ broadcaster = get_status_broadcaster()
+ payload = {
+ "workflow_id": workflow_id,
+ "caller_node_id": caller_node_id,
+ "operations": list(operations),
+ }
+ # Typed envelope constructed for future audit; not on the wire today
+ # because FE listener consumes the flat payload via send_custom_event.
+ _ = workflow_ops_applied(
+ workflow_id=workflow_id,
+ caller_node_id=caller_node_id,
+ operations=operations,
+ )
+ await broadcaster.send_custom_event(_LEGACY_EVENT_TYPE, payload)
+
+
+__all__ = [
+ "broadcast_workflow_ops",
+ "workflow_ops_applied",
+]
diff --git a/server/nodes/trigger/chat_trigger/_events.py b/server/nodes/trigger/chat_trigger/_events.py
new file mode 100644
index 00000000..cd6dbdb3
--- /dev/null
+++ b/server/nodes/trigger/chat_trigger/_events.py
@@ -0,0 +1,61 @@
+"""Wave 12 B7: CloudEvents factory + dispatch wrapper for chat_trigger.
+
+Plugin-specific event emission — replaces:
+ - ``event_waiter.dispatch("chat_message_received", event_data)`` in
+ ``routers/websocket.py:handle_send_chat_message``.
+
+The Chat console message-send handler in the WS router previously
+dispatched the event itself, hardcoding the plugin-specific event_type
+string in framework code. Phase B7 inverts this: the chat_trigger
+plugin owns its own dispatch primitive, the WS handler imports it.
+
+Per RFC plugin_authoring_rfc.md §6.4: plugin-specific factories live
+in the plugin folder.
+
+Legacy ``event_type`` (``"chat_message_received"``) is preserved so
+the ``ChatTriggerNode.event_type`` ClassVar still matches.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from services.events.envelope import WorkflowEvent
+
+
+# Legacy event_type the event_waiter dispatches by; trigger nodes
+# subscribe on this string (matches ``ChatTriggerNode.event_type``).
+_LEGACY_EVENT_TYPE = "chat_message_received"
+
+
+# ---- Typed factory ---------------------------------------------------------
+
+
+def chat_message_received(event_data: Mapping[str, Any]) -> WorkflowEvent:
+ """Incoming chat message envelope. ``subject`` is the session_id so
+ consumers can route per-conversation."""
+ payload = dict(event_data)
+ session_id = payload.get("session_id")
+ return WorkflowEvent(
+ source="machinaos://nodes/chat_trigger",
+ type="com.machinaos.chat.message.received",
+ subject=str(session_id) if session_id else None,
+ data=payload,
+ )
+
+
+# ---- 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."""
+ from services import event_waiter
+
+ return event_waiter.dispatch(_LEGACY_EVENT_TYPE, dict(event_data))
+
+
+__all__ = [
+ "chat_message_received",
+ "dispatch_chat_message_received",
+]
diff --git a/server/nodes/trigger/webhook_trigger/_events.py b/server/nodes/trigger/webhook_trigger/_events.py
new file mode 100644
index 00000000..48e313cd
--- /dev/null
+++ b/server/nodes/trigger/webhook_trigger/_events.py
@@ -0,0 +1,74 @@
+"""Wave 12 B9: CloudEvents factory + dispatch wrapper for webhook_trigger.
+
+Plugin-specific event emission — replaces:
+ - ``broadcaster.send_custom_event("webhook_received", webhook_data)``
+ in ``routers/webhook.py`` (unmapped-path fallback).
+
+The webhook router previously emitted the event itself, hardcoding the
+plugin-specific event_type string in framework code. Phase B9 inverts
+this: the webhook_trigger plugin owns its dispatch primitive.
+
+Per RFC plugin_authoring_rfc.md §6.4: plugin-specific factories live
+in the plugin folder.
+
+Wire-key behaviour preserved: still goes through
+``broadcaster.send_custom_event(...)`` which (a) does the legacy raw
+WS broadcast AND (b) dispatches the event into ``event_waiter`` so
+``webhookTrigger`` nodes match it.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from services.events.envelope import WorkflowEvent
+
+
+# Legacy wire-routing key. The frontend has no listener for it today
+# (webhook receivers don't have a status panel); the consumer is the
+# ``webhookTrigger`` node via the event_waiter dispatch.
+_LEGACY_EVENT_TYPE = "webhook_received"
+
+
+# ---- Typed factory ---------------------------------------------------------
+
+
+def webhook_received(webhook_data: Mapping[str, Any]) -> WorkflowEvent:
+ """Incoming webhook envelope. ``subject`` is the path so consumers
+ can route per-endpoint."""
+ payload = dict(webhook_data)
+ path = payload.get("path")
+ return WorkflowEvent(
+ source="machinaos://nodes/webhook_trigger",
+ type="com.machinaos.webhook.received",
+ subject=str(path) if path else None,
+ data=payload,
+ )
+
+
+# ---- Broadcaster wrapper ---------------------------------------------------
+
+
+async def broadcast_webhook_received(webhook_data: Mapping[str, Any]) -> None:
+ """Broadcast an incoming webhook to ``webhookTrigger`` nodes.
+
+ Routes through ``broadcaster.send_custom_event`` (the existing
+ transport that does both the WS legacy broadcast AND the
+ ``event_waiter`` dispatch). Wire shape unchanged from pre-B9.
+
+ The typed envelope is constructed for future log/audit use even
+ though no FE listener consumes it today.
+ """
+ from services.status_broadcaster import get_status_broadcaster
+
+ broadcaster = get_status_broadcaster()
+ # Build the typed envelope (currently unused on the wire, but
+ # available for any future audit log / DLQ replay).
+ _ = webhook_received(webhook_data)
+ await broadcaster.send_custom_event(_LEGACY_EVENT_TYPE, dict(webhook_data))
+
+
+__all__ = [
+ "broadcast_webhook_received",
+ "webhook_received",
+]
diff --git a/server/routers/webhook.py b/server/routers/webhook.py
index 187341d5..120c79f6 100644
--- a/server/routers/webhook.py
+++ b/server/routers/webhook.py
@@ -18,7 +18,9 @@ import asyncio
import logging
from services.events import WEBHOOK_SOURCES
-from services.status_broadcaster import get_status_broadcaster
+# Wave 12 B9: webhook event dispatch moved to
+# ``nodes/trigger/webhook_trigger/_events.broadcast_webhook_received``.
+# The router no longer reaches into the broadcaster directly.
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/webhook", tags=["webhook"])
@@ -83,8 +85,10 @@ async def handle_webhook(path: str, request: Request):
logger.info(f"[Webhook] Received: {request.method} /webhook/{path}")
- broadcaster = get_status_broadcaster()
- await broadcaster.send_custom_event("webhook_received", webhook_data)
+ # Wave 12 B9: route through plugin _events.py wrapper.
+ from nodes.trigger.webhook_trigger._events import broadcast_webhook_received
+
+ await broadcast_webhook_received(webhook_data)
return JSONResponse(
content={
diff --git a/server/routers/websocket.py b/server/routers/websocket.py
index de89ce76..f13de7c1 100644
--- a/server/routers/websocket.py
+++ b/server/routers/websocket.py
@@ -1655,7 +1655,10 @@ async def handle_send_chat_message(data: Dict[str, Any], websocket: WebSocket) -
them as 'chat_message_received' events to any waiting chatTrigger nodes.
Also saves the message to database for persistence across restarts.
"""
- from services import event_waiter
+ # Wave 12 B7: route through chat_trigger plugin _events.py wrapper —
+ # the chat_message_received event wire shape lives with the plugin,
+ # not in this central WS router.
+ from nodes.trigger.chat_trigger._events import dispatch_chat_message_received
message = data["message"]
role = data.get("role", "user")
@@ -1674,7 +1677,7 @@ async def handle_send_chat_message(data: Dict[str, Any], websocket: WebSocket) -
}
# Dispatch to chatTrigger waiters
- resolved = event_waiter.dispatch("chat_message_received", event_data)
+ resolved = dispatch_chat_message_received(event_data)
logger.info(f"[ChatMessage] Dispatched message to {resolved} chatTrigger waiter(s)")
diff --git a/server/services/handlers/tools.py b/server/services/handlers/tools.py
index eb5575c9..599e706c 100644
--- a/server/services/handlers/tools.py
+++ b/server/services/handlers/tools.py
@@ -505,16 +505,17 @@ async def _execute_delegated_agent(args: Dict[str, Any],
}
)
- # Dispatch error event for trigger nodes
- await broadcaster.send_custom_event('task_completed', {
- 'task_id': task_id,
- 'status': 'error',
- 'agent_name': agent_label,
- 'agent_node_id': node_id,
- 'parent_node_id': config.get('parent_node_id', ''),
- 'error': error_msg,
- 'workflow_id': workflow_id,
- })
+ # Dispatch error event for trigger nodes — Wave 12 B8.
+ from nodes.agent._events import broadcast_agent_task_failed
+
+ await broadcast_agent_task_failed(
+ task_id=task_id,
+ agent_name=agent_label,
+ agent_node_id=node_id,
+ parent_node_id=config.get('parent_node_id', ''),
+ workflow_id=workflow_id,
+ error=error_msg,
+ )
return result
@@ -562,16 +563,17 @@ async def _execute_delegated_agent(args: Dict[str, Any],
}
)
- # Dispatch task_completed event for trigger nodes
- await broadcaster.send_custom_event('task_completed', {
- 'task_id': task_id,
- 'status': 'completed',
- 'agent_name': agent_label,
- 'agent_node_id': node_id,
- 'parent_node_id': config.get('parent_node_id', ''),
- 'result': response_text,
- 'workflow_id': workflow_id,
- })
+ # Dispatch task_completed event for trigger nodes — Wave 12 B8.
+ from nodes.agent._events import broadcast_agent_task_completed
+
+ await broadcast_agent_task_completed(
+ task_id=task_id,
+ agent_name=agent_label,
+ agent_node_id=node_id,
+ parent_node_id=config.get('parent_node_id', ''),
+ workflow_id=workflow_id,
+ result=response_text,
+ )
return result
@@ -613,16 +615,17 @@ async def _execute_delegated_agent(args: Dict[str, Any],
}
)
- # Dispatch task_completed event for trigger nodes (error case)
- await broadcaster.send_custom_event('task_completed', {
- 'task_id': task_id,
- 'status': 'error',
- 'agent_name': agent_label,
- 'agent_node_id': node_id,
- 'parent_node_id': config.get('parent_node_id', ''),
- 'error': str(e),
- 'workflow_id': workflow_id,
- })
+ # Dispatch task_completed event for trigger nodes (error case) — Wave 12 B8.
+ from nodes.agent._events import broadcast_agent_task_failed
+
+ await broadcast_agent_task_failed(
+ task_id=task_id,
+ agent_name=agent_label,
+ agent_node_id=node_id,
+ parent_node_id=config.get('parent_node_id', ''),
+ workflow_id=workflow_id,
+ error=str(e),
+ )
return {"success": False, "error": str(e)}
diff --git a/server/tests/test_status_broadcasts.py b/server/tests/test_status_broadcasts.py
index c668dd12..1586e78a 100644
--- a/server/tests/test_status_broadcasts.py
+++ b/server/tests/test_status_broadcasts.py
@@ -95,24 +95,17 @@ _LEGACY_RAW_DICT_BROADCASTS: FrozenSet[str] = frozenset({
# send_custom_event callsites (message_sent/received + 4 newsletter
# events + history_sync_complete) moved to typed CloudEvents wrappers
# in ``nodes/whatsapp/_events.py``.
-_LEGACY_RAW_DICT_CALLSITES: FrozenSet[str] = frozenset({
- # Webhook router emits ``webhook_received``. Webhook payload is
- # arbitrary JSON; the consumer (webhookTrigger node) shape is
- # already abstract, so a typed envelope adds little value.
- "routers/webhook.py",
- # Task-delegation completion. Migration would namespace as
- # ``agent.task.{succeeded,failed}``; matched by taskTrigger.
- "services/handlers/tools.py",
- # Agent Builder canvas-mutation broadcast. Emits
- # ``workflow_ops_apply`` carrying a flat
- # ``{workflow_id, caller_node_id, operations}`` shape consumed by
- # ``client/src/hooks/useWorkflowOpsListener.ts``. Migration to
- # WorkflowEvent would change the wire format (envelope vs flat),
- # requiring a parallel rewrite of the frontend listener +
- # invariant test fixtures. Deferred — typed-envelope migration
- # tracked alongside the credentials.* / agent.task.* migrations.
- "nodes/tool/agent_builder/__init__.py",
-})
+# Wave 12 B9: ``routers/webhook.py`` retired — webhook_received dispatch
+# moved to ``nodes/trigger/webhook_trigger/_events.py``.
+# Wave 12 B8: ``services/handlers/tools.py`` retired — 3 task_completed
+# callsites moved to ``nodes/agent/_events.py``.
+# Wave 12 B10: ``nodes/tool/agent_builder/__init__.py`` retired —
+# workflow_ops_apply dispatch moved to
+# ``nodes/tool/agent_builder/_events.py``.
+#
+# Allowlist now empty: every send_custom_event callsite lives in a
+# plugin folder's _events.py wrapper.
+_LEGACY_RAW_DICT_CALLSITES: FrozenSet[str] = frozenset()
# ============================================================================