Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
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.pynew file mode 100644index 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__.pyindex 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-exportfrom ._filters import build_filter as build_email_filterregister_filter_builder("emailReceive", build_email_filter)diff --git a/server/nodes/email/_events.py b/server/nodes/email/_events.pynew file mode 100644index 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__.pyindex 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 datetimefrom .._service import get_email_servicefrom services.status_broadcaster import get_status_broadcaster- from services import event_waiterstart_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__.pyindex 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-exportfrom ._filters import build_gmail_filterfrom ._handlers import WS_HANDLERSfrom ._option_loaders import (diff --git a/server/nodes/google/_events.py b/server/nodes/google/_events.pynew file mode 100644index 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__.pyindex 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_waiterfrom services.status_broadcaster import get_status_broadcasterstart_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__.pyindex 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 itsworkflow_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 mademid-run does NOT add a callable tool to the current run; theagent'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:returntry:- 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pyindex 187341d5..120c79f6 100644--- a/server/routers/webhook.py+++ b/server/routers/webhook.py@@ -18,7 +18,9 @@ import asyncioimport loggingfrom 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.pyindex 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_receivedmessage = 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.pyindex 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.pyindex 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()# ============================================================================