machinaos 0.0.1

package/server/routers/websocket.py

@@ -0,0 +1,2127 @@
+"""WebSocket router for real-time bidirectional communication.
+
+Handles WebSocket connections from frontend clients for ALL operations:
+- Node parameters (get, save, delete)
+- Node execution
+- AI execution and model fetching
+- API key validation and storage
+- Android device operations
+- Google Maps key validation
+- Status broadcasts
+"""
+
+import time
+import asyncio
+import weakref
+from typing import Dict, Any, Callable, Awaitable, Optional, Set
+from datetime import datetime
+
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+from services.status_broadcaster import get_status_broadcaster
+from core.container import container
+from core.logging import get_logger
+
+logger = get_logger(__name__)
+
+router = APIRouter(tags=["websocket"])
+
+# =============================================================================
+# Concurrent Send Protection
+# =============================================================================
+# Use WeakKeyDictionary to auto-cleanup when WebSocket is garbage collected
+_send_locks: weakref.WeakKeyDictionary = weakref.WeakKeyDictionary()
+
+# Track running handler tasks per WebSocket for cleanup on disconnect
+_handler_tasks: weakref.WeakKeyDictionary = weakref.WeakKeyDictionary()
+
+
+async def _safe_send(websocket: WebSocket, data: dict):
+    """Thread-safe WebSocket send with lock to prevent concurrent writes."""
+    if websocket not in _send_locks:
+        _send_locks[websocket] = asyncio.Lock()
+    async with _send_locks[websocket]:
+        try:
+            await websocket.send_json(data)
+        except Exception as e:
+            logger.error(f"[WebSocket] Send error: {e}")
+
+
+# Type for message handlers
+MessageHandler = Callable[[Dict[str, Any], WebSocket], Awaitable[Dict[str, Any]]]
+
+
+def ws_handler(*required_fields: str):
+    """Simple decorator for WebSocket handlers. Validates required fields and wraps errors."""
+    def decorator(func: MessageHandler) -> MessageHandler:
+        async def wrapper(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+            for field in required_fields:
+                if not data.get(field):
+                    return {"success": False, "error": f"{field} required"}
+            try:
+                result = await func(data, websocket)
+                if "success" not in result:
+                    result = {"success": True, **result}
+                return result
+            except Exception as e:
+                logger.error(f"Handler error: {e}", exc_info=True)
+                return {"success": False, "error": str(e)}
+        return wrapper
+    return decorator
+
+
+# ============================================================================
+# Message Handlers
+# ============================================================================
+
+async def handle_ping(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Handle ping request."""
+    return {"type": "pong", "timestamp": time.time()}
+
+
+async def handle_get_status(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get current full status."""
+    broadcaster = get_status_broadcaster()
+    return {"type": "full_status", "data": broadcaster.get_status()}
+
+
+async def handle_get_android_status(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get Android connection status."""
+    broadcaster = get_status_broadcaster()
+    return {"type": "android_status", "data": broadcaster.get_android_status()}
+
+
+async def handle_get_node_status(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get specific node status."""
+    broadcaster = get_status_broadcaster()
+    node_id = data.get("node_id")
+    if node_id:
+        status = broadcaster.get_node_status(node_id)
+        return {"type": "node_status", "node_id": node_id, "data": status}
+    return {"type": "error", "message": "node_id required"}
+
+
+async def handle_get_variable(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get variable value."""
+    broadcaster = get_status_broadcaster()
+    name = data.get("name")
+    if name:
+        value = broadcaster.get_variable(name)
+        return {"type": "variable_update", "name": name, "value": value}
+    return {"type": "error", "message": "name required"}
+
+
+# ============================================================================
+# Node Parameters Handlers
+# ============================================================================
+
+@ws_handler("node_id")
+async def handle_get_node_parameters(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get parameters for a specific node."""
+    database = container.database()
+    node_id = data["node_id"]
+    parameters = await database.get_node_parameters(node_id)
+    logger.debug(f"[GET_PARAMS] Node ID: {node_id}")
+    logger.debug(f"[GET_PARAMS] Raw from DB: {parameters}")
+    logger.debug(f"[GET_PARAMS] Code length: {len(parameters.get('code', '')) if parameters and 'code' in parameters else 'no code field'}")
+    return {"node_id": node_id, "parameters": parameters or {}, "version": 1, "timestamp": time.time()}
+
+
+@ws_handler()
+async def handle_get_all_node_parameters(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get parameters for multiple nodes."""
+    database = container.database()
+    result = {}
+    for node_id in data.get("node_ids", []):
+        parameters = await database.get_node_parameters(node_id)
+        if parameters:
+            result[node_id] = {"parameters": parameters, "version": 1}
+    return {"parameters": result, "timestamp": time.time()}
+
+
+@ws_handler("node_id")
+async def handle_save_node_parameters(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Save node parameters and broadcast to all clients."""
+    database = container.database()
+    broadcaster = get_status_broadcaster()
+    node_id, parameters = data["node_id"], data.get("parameters", {})
+
+    logger.debug(f"[SAVE_PARAMS] Node ID: {node_id}, has_code: {'code' in parameters}, code_len: {len(parameters.get('code', '')) if 'code' in parameters else 0}")
+    await database.save_node_parameters(node_id, parameters)
+    await broadcaster.broadcast({
+        "type": "node_parameters_updated", "node_id": node_id,
+        "parameters": parameters, "version": 1, "timestamp": time.time()
+    })
+    return {"node_id": node_id, "parameters": parameters, "version": 1, "timestamp": time.time()}
+
+
+@ws_handler("node_id")
+async def handle_delete_node_parameters(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Delete node parameters."""
+    database = container.database()
+    await database.delete_node_parameters(data["node_id"])
+    return {"node_id": data["node_id"]}
+
+
+# ============================================================================
+# Tool Schema Handlers (Source of truth for tool node configurations)
+# ============================================================================
+
+@ws_handler("node_id")
+async def handle_get_tool_schema(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get tool schema for a node."""
+    database = container.database()
+    schema = await database.get_tool_schema(data["node_id"])
+    return {"node_id": data["node_id"], "schema": schema}
+
+
+@ws_handler("node_id", "tool_name", "tool_description", "schema_config")
+async def handle_save_tool_schema(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Save tool schema for a node. Used by Android Toolkit to update connected service schemas."""
+    database = container.database()
+    broadcaster = get_status_broadcaster()
+
+    node_id = data["node_id"]
+    tool_name = data["tool_name"]
+    tool_description = data["tool_description"]
+    schema_config = data["schema_config"]
+    connected_services = data.get("connected_services")
+
+    success = await database.save_tool_schema(
+        node_id=node_id,
+        tool_name=tool_name,
+        tool_description=tool_description,
+        schema_config=schema_config,
+        connected_services=connected_services
+    )
+
+    if success:
+        # Broadcast schema update to all clients
+        await broadcaster.broadcast({
+            "type": "tool_schema_updated",
+            "node_id": node_id,
+            "tool_name": tool_name,
+            "timestamp": time.time()
+        })
+
+    return {
+        "node_id": node_id,
+        "tool_name": tool_name,
+        "saved": success
+    }
+
+
+@ws_handler("node_id")
+async def handle_delete_tool_schema(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Delete tool schema for a node."""
+    database = container.database()
+    await database.delete_tool_schema(data["node_id"])
+    return {"node_id": data["node_id"]}
+
+
+async def handle_get_all_tool_schemas(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get all tool schemas."""
+    database = container.database()
+    schemas = await database.get_all_tool_schemas()
+    return {"success": True, "schemas": schemas}
+
+
+# ============================================================================
+# Node Execution Handlers
+# ============================================================================
+
+@ws_handler("node_id", "node_type")
+async def handle_execute_node(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Execute a workflow node with per-workflow status scoping (n8n pattern)."""
+    workflow_service = container.workflow_service()
+    broadcaster = get_status_broadcaster()
+    node_id, node_type = data["node_id"], data["node_type"]
+    workflow_id = data.get("workflow_id")  # Per-workflow isolation
+
+    await broadcaster.update_node_status(node_id, "executing", workflow_id=workflow_id)
+    result = await workflow_service.execute_node(
+        node_id=node_id, node_type=node_type,
+        parameters=data.get("parameters", {}),
+        nodes=data.get("nodes", []), edges=data.get("edges", []),
+        session_id=data.get("session_id", "default"),
+        workflow_id=workflow_id,
+    )
+
+    if result.get("success"):
+        await broadcaster.update_node_status(node_id, "success", result.get("result"), workflow_id=workflow_id)
+        await broadcaster.update_node_output(node_id, result.get("result"), workflow_id=workflow_id)
+    elif result.get("error") == "Cancelled by user":
+        # Cancelled trigger nodes go back to idle, not error
+        await broadcaster.update_node_status(node_id, "idle", {"message": "Cancelled"}, workflow_id=workflow_id)
+    else:
+        await broadcaster.update_node_status(node_id, "error", {"error": result.get("error")}, workflow_id=workflow_id)
+
+    # Explicitly pass through success status (don't let decorator default to True)
+    ws_result = {
+        "success": result.get("success", False),
+        "node_id": node_id,
+        "result": result.get("result"),
+        "error": result.get("error"),
+        "execution_time": result.get("execution_time"),
+        "timestamp": time.time()
+    }
+    # Debug: Log what we're returning to WebSocket
+    result_data = result.get("result")
+    logger.debug(f"[WS execute_node] Returning: success={ws_result['success']}, result.response={repr(result_data.get('response', 'MISSING')[:100] if result_data and result_data.get('response') else 'None')}")
+    return ws_result
+
+
+@ws_handler("node_id")
+async def handle_cancel_execution(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Cancel node execution."""
+    broadcaster = get_status_broadcaster()
+    await broadcaster.update_node_status(data["node_id"], "idle")
+    return {"node_id": data["node_id"], "message": "Execution cancelled"}
+
+
+@ws_handler()
+async def handle_cancel_event_wait(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Cancel an active event waiter (for trigger nodes).
+
+    Can cancel by waiter_id or node_id.
+    Note: Status update to "idle" happens in handle_execute_node when it catches CancelledError.
+    """
+    from services import event_waiter
+
+    waiter_id = data.get("waiter_id")
+    node_id = data.get("node_id")
+
+    logger.debug(f"[WebSocket] handle_cancel_event_wait called: waiter_id={waiter_id}, node_id={node_id}")
+
+    if waiter_id:
+        success = event_waiter.cancel(waiter_id)
+        logger.debug(f"[WebSocket] cancel by waiter_id result: success={success}")
+        return {"success": success, "waiter_id": waiter_id, "message": "Cancelled" if success else "Not found"}
+    elif node_id:
+        count = event_waiter.cancel_for_node(node_id)
+        logger.debug(f"[WebSocket] cancel by node_id result: cancelled_count={count}")
+        return {"success": count > 0, "node_id": node_id, "cancelled_count": count}
+    else:
+        return {"success": False, "error": "waiter_id or node_id required"}
+
+
+@ws_handler()
+async def handle_get_active_waiters(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get list of active event waiters (for debugging/UI)."""
+    from services import event_waiter
+    return {"waiters": event_waiter.get_active_waiters()}
+
+
+# ============================================================================
+# Dead Letter Queue (DLQ) Handlers
+# ============================================================================
+
+@ws_handler()
+async def handle_get_dlq_entries(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get DLQ entries with optional filtering.
+
+    Optional params:
+        workflow_id: Filter by workflow ID
+        node_type: Filter by node type
+        limit: Max entries to return (default 100)
+
+    Returns:
+        List of DLQ entries
+    """
+    from services.execution import ExecutionCache
+    cache_service = container.cache()
+    execution_cache = ExecutionCache(cache_service)
+
+    entries = await execution_cache.get_dlq_entries(
+        workflow_id=data.get("workflow_id"),
+        node_type=data.get("node_type"),
+        limit=data.get("limit", 100)
+    )
+
+    return {
+        "entries": [entry.to_dict() for entry in entries],
+        "count": len(entries),
+        "timestamp": time.time()
+    }
+
+
+@ws_handler("entry_id")
+async def handle_get_dlq_entry(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get a single DLQ entry by ID.
+
+    Required:
+        entry_id: DLQ entry ID
+
+    Returns:
+        DLQ entry details
+    """
+    from services.execution import ExecutionCache
+    cache_service = container.cache()
+    execution_cache = ExecutionCache(cache_service)
+
+    entry = await execution_cache.get_dlq_entry(data["entry_id"])
+
+    if entry:
+        return {"entry": entry.to_dict(), "timestamp": time.time()}
+    else:
+        return {"success": False, "error": "DLQ entry not found"}
+
+
+@ws_handler()
+async def handle_get_dlq_stats(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get DLQ statistics.
+
+    Returns:
+        Total count, breakdown by node type and workflow
+    """
+    from services.execution import ExecutionCache
+    cache_service = container.cache()
+    execution_cache = ExecutionCache(cache_service)
+
+    stats = await execution_cache.get_dlq_stats()
+    return {"stats": stats, "timestamp": time.time()}
+
+
+@ws_handler("entry_id")
+async def handle_replay_dlq_entry(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Replay a failed node from the DLQ.
+
+    Required:
+        entry_id: DLQ entry ID to replay
+        nodes: Workflow nodes
+        edges: Workflow edges
+
+    Returns:
+        Replay execution result
+    """
+    from services.execution import ExecutionCache, WorkflowExecutor
+    cache_service = container.cache()
+    execution_cache = ExecutionCache(cache_service)
+    workflow_service = container.workflow_service()
+    broadcaster = get_status_broadcaster()
+
+    entry_id = data["entry_id"]
+    nodes = data.get("nodes", [])
+    edges = data.get("edges", [])
+
+    # Get the entry to find the node_id
+    entry = await execution_cache.get_dlq_entry(entry_id)
+    if not entry:
+        return {"success": False, "error": "DLQ entry not found"}
+
+    # Update status
+    await broadcaster.update_node_status(entry.node_id, "executing", {
+        "message": "Replaying from DLQ"
+    })
+
+    # Create executor with node adapter
+    async def node_executor(node_id: str, node_type: str, params: dict, context: dict) -> dict:
+        return await workflow_service.execute_node(
+            node_id=node_id,
+            node_type=node_type,
+            parameters=params,
+            nodes=context.get("nodes", []),
+            edges=context.get("edges", []),
+            session_id=context.get("session_id", "dlq_replay"),
+            execution_id=context.get("execution_id")
+        )
+
+    async def status_callback(node_id: str, status: str, status_data: dict):
+        await broadcaster.update_node_status(node_id, status, status_data)
+
+    # DLQ replay needs DLQ enabled to re-add on failure
+    settings = container.settings()
+    executor = WorkflowExecutor(
+        cache=execution_cache,
+        node_executor=node_executor,
+        status_callback=status_callback,
+        dlq_enabled=settings.dlq_enabled
+    )
+
+    result = await executor.replay_dlq_entry(entry_id, nodes, edges)
+
+    # Update final status
+    if result.get("success"):
+        await broadcaster.update_node_status(entry.node_id, "success", result.get("result"))
+    else:
+        await broadcaster.update_node_status(entry.node_id, "error", {"error": result.get("error")})
+
+    return result
+
+
+@ws_handler("entry_id")
+async def handle_remove_dlq_entry(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Remove an entry from the DLQ without replaying.
+
+    Required:
+        entry_id: DLQ entry ID to remove
+
+    Returns:
+        Success status
+    """
+    from services.execution import ExecutionCache
+    cache_service = container.cache()
+    execution_cache = ExecutionCache(cache_service)
+
+    success = await execution_cache.remove_from_dlq(data["entry_id"])
+    return {"removed": success, "entry_id": data["entry_id"]}
+
+
+@ws_handler()
+async def handle_purge_dlq(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Purge entries from the DLQ.
+
+    Optional params:
+        workflow_id: Only purge entries for this workflow
+        node_type: Only purge entries for this node type
+        older_than_hours: Only purge entries older than X hours
+
+    Returns:
+        Number of entries purged
+    """
+    from services.execution import ExecutionCache
+    cache_service = container.cache()
+    execution_cache = ExecutionCache(cache_service)
+
+    older_than = None
+    if data.get("older_than_hours"):
+        older_than = time.time() - (data["older_than_hours"] * 3600)
+
+    purged = await execution_cache.purge_dlq(
+        workflow_id=data.get("workflow_id"),
+        node_type=data.get("node_type"),
+        older_than=older_than
+    )
+
+    return {"purged": purged, "timestamp": time.time()}
+
+
+@ws_handler("node_id")
+async def handle_get_node_output(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get output data for a specific node."""
+    workflow_service = container.workflow_service()
+    node_id = data["node_id"]
+    output_name = data.get("output_name", "output_0")
+    output_data = await workflow_service.get_node_output(data.get("session_id", "default"), node_id, output_name)
+    return {"node_id": node_id, "output_name": output_name, "data": output_data, "timestamp": time.time()}
+
+
+@ws_handler("node_id")
+async def handle_clear_node_output(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Clear output data for a specific node from memory, database, and broadcaster cache."""
+    workflow_service = container.workflow_service()
+    database = container.database()
+    broadcaster = get_status_broadcaster()
+    node_id = data["node_id"]
+
+    # Clear from memory - find keys ending with _{node_id}
+    memory_cleared = 0
+    keys_to_delete = [key for key in workflow_service.node_outputs.keys() if key.endswith(f"_{node_id}")]
+    for key in keys_to_delete:
+        del workflow_service.node_outputs[key]
+        memory_cleared += 1
+
+    # Clear from database (persisted storage)
+    db_cleared = await database.delete_node_output(node_id)
+
+    # Clear from broadcaster's status cache (prevents reload from showing old data)
+    broadcaster_cleared = await broadcaster.clear_node_status(node_id)
+
+    logger.info("Cleared node output", node_id=node_id, memory_cleared=memory_cleared,
+                db_cleared=db_cleared, broadcaster_cleared=broadcaster_cleared)
+
+    return {"node_id": node_id, "cleared": True, "memory_cleared": memory_cleared,
+            "db_cleared": db_cleared, "broadcaster_cleared": broadcaster_cleared}
+
+
+@ws_handler()
+async def handle_execute_workflow(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Execute entire workflow from start node to end.
+
+    Expects:
+        workflow_id: Workflow identifier for per-workflow status scoping
+        nodes: List of workflow nodes with {id, type, data}
+        edges: List of edges with {id, source, target}
+        session_id: Optional session identifier
+
+    Returns:
+        Workflow execution result with all node outputs
+    """
+    workflow_service = container.workflow_service()
+    broadcaster = get_status_broadcaster()
+
+    workflow_id = data.get("workflow_id")  # Per-workflow isolation (n8n pattern)
+    nodes = data.get("nodes", [])
+    edges = data.get("edges", [])
+    session_id = data.get("session_id", "default")
+
+    if not nodes:
+        return {"success": False, "error": "No nodes provided"}
+
+    # Broadcast workflow starting status
+    await broadcaster.update_workflow_status(executing=True, current_node=None, progress=0)
+
+    # Create status callback with workflow_id for per-workflow scoping (n8n pattern)
+    async def status_callback(node_id: str, status: str, node_data: Optional[Dict] = None):
+        await broadcaster.update_node_status(node_id, status, node_data, workflow_id=workflow_id)
+        if status == "executing":
+            position = node_data.get("position", 0) if node_data else 0
+            total = node_data.get("total", 1) if node_data else 1
+            progress = int((position / total) * 100) if total > 0 else 0
+            await broadcaster.update_workflow_status(executing=True, current_node=node_id, progress=progress)
+
+    # Execute the workflow with workflow_id for per-workflow status scoping
+    result = await workflow_service.execute_workflow(
+        nodes=nodes,
+        edges=edges,
+        session_id=session_id,
+        status_callback=status_callback,
+        workflow_id=workflow_id,
+    )
+
+    # Broadcast workflow completed status
+    await broadcaster.update_workflow_status(
+        executing=False,
+        current_node=None,
+        progress=100 if result.get("success") else 0
+    )
+
+    return {
+        "success": result.get("success", False),
+        "nodes_executed": result.get("nodes_executed", []),
+        "node_results": result.get("node_results", {}),
+        "execution_order": result.get("execution_order", []),
+        "errors": result.get("errors", []),
+        "error": result.get("error"),
+        "total_nodes": result.get("total_nodes", 0),
+        "completed_nodes": result.get("completed_nodes", 0),
+        "execution_time": result.get("execution_time", 0),
+        "timestamp": time.time()
+    }
+
+
+# Per-workflow deployment tasks for proper cancellation (Temporal/n8n pattern)
+# Maps workflow_id -> asyncio.Task for parallel workflow deployments
+_deployment_tasks: Dict[str, asyncio.Task] = {}
+
+
+@ws_handler()
+async def handle_deploy_workflow(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Deploy workflow to run continuously until cancelled.
+
+    Expects:
+        workflow_id: Workflow identifier (required for locking)
+        nodes: List of workflow nodes with {id, type, data}
+        edges: List of edges with {id, source, target}
+        session_id: Optional session identifier
+        delay_between_runs: Optional delay in seconds between iterations (default: 1.0)
+
+    Returns:
+        Deployment start confirmation (deployment runs in background)
+    """
+    global _deployment_tasks
+    workflow_service = container.workflow_service()
+    broadcaster = get_status_broadcaster()
+
+    workflow_id = data.get("workflow_id")
+    nodes = data.get("nodes", [])
+    edges = data.get("edges", [])
+    session_id = data.get("session_id", "default")
+
+    # DEBUG: Log received edges to trace tool connection issues
+    logger.info(f"[Deploy] Received {len(edges)} edges for workflow {workflow_id}")
+    for e in edges:
+        target_handle = e.get('targetHandle')
+        if target_handle and target_handle.startswith('input-') and target_handle != 'input-main':
+            logger.info(f"[Deploy] Config edge: {e.get('source')} -> {e.get('target')} (handle={target_handle})")
+
+    # Check for tool connections to AI Agent
+    tool_edges = [e for e in edges if e.get('targetHandle') == 'input-tools']
+    if tool_edges:
+        logger.info(f"[Deploy] Tool edges found: {len(tool_edges)}")
+        for te in tool_edges:
+            logger.info(f"[Deploy] Tool edge: source={te.get('source')} -> target={te.get('target')}")
+    else:
+        logger.info(f"[Deploy] No input-tools edges found")
+
+    if not nodes:
+        return {"success": False, "error": "No nodes provided"}
+
+    if not workflow_id:
+        return {"success": False, "error": "workflow_id is required for deployment"}
+
+    # Check if THIS specific workflow is already deployed (per-workflow isolation)
+    if workflow_service.is_workflow_deployed(workflow_id):
+        status = workflow_service.get_deployment_status(workflow_id)
+        return {
+            "success": False,
+            "error": f"Workflow {workflow_id} is already deployed. Cancel it first.",
+            "workflow_id": workflow_id,
+            "is_running": True,
+            "run_counter": status.get("run_counter", 0)
+        }
+
+    # Acquire workflow lock before starting deployment (per-workflow locking - n8n pattern)
+    lock_acquired = await broadcaster.lock_workflow(workflow_id, reason="deployment")
+    if not lock_acquired:
+        lock_info = broadcaster.get_workflow_lock(workflow_id)
+        return {
+            "success": False,
+            "error": f"Workflow {workflow_id} is already locked for {lock_info.get('reason', 'deployment')}",
+            "locked_by": lock_info.get("workflow_id"),
+            "locked_at": lock_info.get("locked_at")
+        }
+
+    # Broadcast deployment starting status using centralized method
+    await broadcaster.update_workflow_status(executing=True, current_node=None, progress=0)
+    await broadcaster.update_deployment_status(
+        is_running=True,
+        status="starting",
+        active_runs=0,
+        workflow_id=workflow_id
+    )
+
+    # Create status callback to broadcast node and deployment updates
+    # Include workflow_id in all node status updates (n8n pattern for workflow isolation)
+    async def status_callback(node_id: str, status: str, node_data: Optional[Dict] = None):
+        if node_id == "__deployment__":
+            # Deployment-level status update using centralized method
+            active_runs = node_data.get("active_runs", 0) if node_data else 0
+            await broadcaster.update_deployment_status(
+                is_running=True,
+                status=status,
+                active_runs=active_runs,
+                workflow_id=workflow_id,
+                data=node_data
+            )
+        else:
+            # Node-level status update with workflow_id for frontend filtering
+            await broadcaster.update_node_status(node_id, status, node_data, workflow_id=workflow_id)
+            if status == "executing":
+                position = node_data.get("position", 0) if node_data else 0
+                total = node_data.get("total", 1) if node_data else 1
+                progress = int((position / total) * 100) if total > 0 else 0
+                await broadcaster.update_workflow_status(executing=True, current_node=node_id, progress=progress)
+
+    # Start deployment as background task (per-workflow - Temporal/n8n pattern)
+    # In the event-driven pattern, deploy_workflow() returns immediately after setting up triggers.
+    # The workflow stays locked until cancel_deployment is called.
+    async def run_deployment():
+        try:
+            result = await workflow_service.deploy_workflow(
+                nodes=nodes,
+                edges=edges,
+                session_id=session_id,
+                status_callback=status_callback,
+                workflow_id=workflow_id
+            )
+
+            # In event-driven mode, deploy_workflow returns immediately after trigger setup.
+            # If it failed, unlock and report error. If successful, stay running.
+            if not result.get("success"):
+                # Setup failed - unlock and report error
+                logger.error("Deployment setup failed", error=result.get("error"), workflow_id=workflow_id)
+                await broadcaster.update_deployment_status(
+                    is_running=False,
+                    status="error",
+                    active_runs=0,
+                    workflow_id=workflow_id,
+                    error=result.get("error")
+                )
+                await broadcaster.unlock_workflow(workflow_id)
+                # Clean up task reference for this workflow
+                _deployment_tasks.pop(workflow_id, None)
+            else:
+                # Deployment successful - triggers are set up and running.
+                # Workflow stays locked until cancel_deployment is called.
+                await broadcaster.update_deployment_status(
+                    is_running=True,
+                    status="running",
+                    active_runs=0,
+                    workflow_id=workflow_id,
+                    data={
+                        "triggers_setup": result.get("triggers_setup", []),
+                        "deployment_id": result.get("deployment_id")
+                    }
+                )
+                logger.info("[Deployment] Event-driven deployment active",
+                           deployment_id=result.get("deployment_id"),
+                           workflow_id=workflow_id,
+                           triggers=len(result.get("triggers_setup", [])))
+
+        except Exception as e:
+            logger.error("Deployment task error", workflow_id=workflow_id, error=str(e))
+            await broadcaster.update_deployment_status(
+                is_running=False,
+                status="error",
+                active_runs=0,
+                workflow_id=workflow_id,
+                error=str(e)
+            )
+            await broadcaster.unlock_workflow(workflow_id)
+            # Clean up task reference for this workflow
+            _deployment_tasks.pop(workflow_id, None)
+
+    # Store task per workflow for independent cancellation
+    _deployment_tasks[workflow_id] = asyncio.create_task(run_deployment())
+
+    return {
+        "success": True,
+        "message": "Deployment started",
+        "workflow_id": workflow_id,
+        "is_running": True,
+        "locked": True,
+        "timestamp": time.time()
+    }
+
+
+@ws_handler()
+async def handle_cancel_deployment(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Cancel running deployment for a specific workflow (Temporal/n8n pattern).
+
+    Expects:
+        workflow_id: Workflow to cancel (required).
+
+    Also cancels any active event waiters (trigger nodes) and unlocks the workflow.
+
+    Returns:
+        Cancellation result with iterations completed
+    """
+    global _deployment_tasks
+    from services import event_waiter
+
+    workflow_service = container.workflow_service()
+    broadcaster = get_status_broadcaster()
+
+    workflow_id = data.get("workflow_id")
+
+    if not workflow_id:
+        return {"success": False, "error": "workflow_id is required for cancellation"}
+
+    result = await workflow_service.cancel_deployment(workflow_id)
+
+    # Cancel event waiters for this specific workflow's nodes
+    cancelled_waiters = 0
+    if result.get("success"):
+        cancelled_waiters = result.get("waiters_cancelled", 0)
+
+    # Cancel the deployment task for THIS specific workflow only (per-workflow isolation)
+    task = _deployment_tasks.pop(workflow_id, None)
+    if task and not task.done():
+        task.cancel()
+        try:
+            await task
+        except asyncio.CancelledError:
+            logger.info("[Deployment] Deployment task cancelled", workflow_id=workflow_id)
+
+    # Unlock this specific workflow
+    if workflow_id:
+        await broadcaster.unlock_workflow(workflow_id)
+
+    if result.get("success"):
+        # Clear node statuses for all trigger nodes that were waiting
+        # The result contains info about cancelled listeners (listener_{node_id})
+        # Use existing clear_node_status method which broadcasts node_status_cleared
+        for node_id in result.get("cancelled_listener_node_ids", []):
+            await broadcaster.clear_node_status(node_id)
+
+        # Broadcast deployment cancelled status using centralized method
+        await broadcaster.update_workflow_status(executing=False, current_node=None, progress=0)
+        await broadcaster.update_deployment_status(
+            is_running=False,
+            status="cancelled",
+            active_runs=0,
+            workflow_id=workflow_id,
+            data={
+                "iterations_completed": result.get("iterations_completed", 0)
+            }
+        )
+
+    return {
+        "success": result.get("success", False),
+        "message": result.get("message", result.get("error")),
+        "workflow_id": workflow_id,
+        "was_running": result.get("was_running", False),
+        "iterations_completed": result.get("iterations_completed", 0),
+        "cancelled_waiters": cancelled_waiters,
+        "unlocked": workflow_id is not None,
+        "timestamp": time.time()
+    }
+
+
+@ws_handler()
+async def handle_get_deployment_status(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get current deployment status including workflow lock info.
+
+    Expects (optional):
+        workflow_id: Get status for specific workflow. If not provided, returns global status.
+
+    Returns:
+        Current deployment state, iteration count, and lock status
+    """
+    workflow_service = container.workflow_service()
+    broadcaster = get_status_broadcaster()
+
+    workflow_id = data.get("workflow_id")
+    status = workflow_service.get_deployment_status(workflow_id)
+
+    return {
+        "is_running": workflow_service.is_deployment_running(workflow_id),
+        "run_counter": status.get("run_counter", 0),
+        "active_runs": status.get("active_runs", 0),
+        "settings": workflow_service.get_deployment_settings(),
+        "workflow_id": workflow_id or status.get("workflow_id"),
+        "deployed_workflows": status.get("deployed_workflows", []),
+        "lock": broadcaster.get_workflow_lock(),
+        "timestamp": time.time()
+    }
+
+
+@ws_handler()
+async def handle_get_workflow_lock(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get current workflow lock status.
+
+    Returns:
+        Current lock state including locked workflow_id and reason
+    """
+    broadcaster = get_status_broadcaster()
+
+    return {
+        "lock": broadcaster.get_workflow_lock(),
+        "timestamp": time.time()
+    }
+
+
+@ws_handler()
+async def handle_update_deployment_settings(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Update deployment settings (can be called during active deployment).
+
+    Expects any of:
+        delay_between_runs: float - Seconds to wait between iterations
+        stop_on_error: bool - Stop deployment when a node fails
+        max_iterations: int - Max iterations (0 = unlimited)
+
+    Returns:
+        Updated settings and current deployment state
+    """
+    workflow_service = container.workflow_service()
+    broadcaster = get_status_broadcaster()
+
+    settings_to_update = {}
+    if "delay_between_runs" in data:
+        settings_to_update["delay_between_runs"] = data["delay_between_runs"]
+    if "stop_on_error" in data:
+        settings_to_update["stop_on_error"] = data["stop_on_error"]
+    if "max_iterations" in data:
+        settings_to_update["max_iterations"] = data["max_iterations"]
+
+    updated_settings = await workflow_service.update_deployment_settings(settings_to_update)
+
+    # Broadcast settings update
+    status = workflow_service.get_deployment_status()
+    await broadcaster.broadcast({
+        "type": "deployment_settings_updated",
+        "settings": updated_settings,
+        "is_running": workflow_service.is_deployment_running(),
+        "run_counter": status.get("run_counter", 0)
+    })
+
+    return {
+        "success": True,
+        "settings": updated_settings,
+        "is_running": workflow_service.is_deployment_running(),
+        "run_counter": status.get("run_counter", 0),
+        "active_runs": status.get("active_runs", 0),
+        "timestamp": time.time()
+    }
+
+
+# ============================================================================
+# AI Handlers
+# ============================================================================
+
+@ws_handler("node_id", "node_type")
+async def handle_execute_ai_node(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Execute an AI node (chat model or agent)."""
+    workflow_service = container.workflow_service()
+    broadcaster = get_status_broadcaster()
+    node_id, node_type = data["node_id"], data["node_type"]
+
+    await broadcaster.update_node_status(node_id, "executing")
+    result = await workflow_service.execute_node(
+        node_id=node_id, node_type=node_type,
+        parameters=data.get("parameters", {}),
+        nodes=data.get("nodes", []), edges=data.get("edges", []),
+        session_id=data.get("session_id", "default")
+    )
+
+    if result.get("success"):
+        await broadcaster.update_node_status(node_id, "success", result.get("result"))
+        await broadcaster.update_node_output(node_id, result.get("result"))
+    else:
+        await broadcaster.update_node_status(node_id, "error", {"error": result.get("error")})
+
+    return {"node_id": node_id, "result": result.get("result"), "error": result.get("error"),
+            "execution_time": result.get("execution_time"), "timestamp": time.time()}
+
+
+@ws_handler("provider", "api_key")
+async def handle_get_ai_models(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get available AI models for a provider."""
+    ai_service = container.ai_service()
+    models = await ai_service.fetch_models(data["provider"], data["api_key"])
+    return {"provider": data["provider"], "models": models, "timestamp": time.time()}
+
+
+# ============================================================================
+# API Key Handlers
+# ============================================================================
+
+@ws_handler("provider", "api_key")
+async def handle_validate_api_key(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Validate and store an API key."""
+    ai_service = container.ai_service()
+    auth_service = container.auth_service()
+    broadcaster = get_status_broadcaster()
+    provider, api_key = data["provider"].lower(), data["api_key"].strip()
+
+    models = await ai_service.fetch_models(provider, api_key)
+    await auth_service.store_api_key(provider=provider, api_key=api_key, models=models,
+                                      session_id=data.get("session_id", "default"))
+    # Broadcast with hasKey and models so frontend can update reactively
+    await broadcaster.update_api_key_status(
+        provider=provider, valid=True, message="API key validated",
+        has_key=True, models=models
+    )
+    return {"provider": provider, "valid": True, "models": models, "timestamp": time.time()}
+
+
+@ws_handler("provider")
+async def handle_get_stored_api_key(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get stored API key for a provider."""
+    auth_service = container.auth_service()
+    provider = data["provider"].lower()
+    api_key = await auth_service.get_api_key(provider, data.get("session_id", "default"))
+    if not api_key:
+        return {"provider": provider, "has_key": False}
+    models = await auth_service.get_stored_models(provider, data.get("session_id", "default"))
+    return {"provider": provider, "has_key": True, "api_key": api_key, "models": models, "timestamp": time.time()}
+
+
+@ws_handler("provider", "api_key")
+async def handle_save_api_key(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Save an API key (without validation)."""
+    auth_service = container.auth_service()
+    await auth_service.store_api_key(provider=data["provider"].lower(), api_key=data["api_key"].strip(),
+                                      models=data.get("models", []), session_id=data.get("session_id", "default"))
+    return {"provider": data["provider"]}
+
+
+@ws_handler("provider")
+async def handle_delete_api_key(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Delete stored API key."""
+    auth_service = container.auth_service()
+    await auth_service.remove_api_key(data["provider"].lower(), data.get("session_id", "default"))
+    return {"provider": data["provider"]}
+
+
+# ============================================================================
+# Android Handlers
+# ============================================================================
+
+@ws_handler()
+async def handle_get_android_devices(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get list of connected Android devices."""
+    android_service = container.android_service()
+    devices = await android_service.list_devices()
+    return {"devices": devices, "timestamp": time.time()}
+
+
+@ws_handler("service_id", "action")
+async def handle_execute_android_action(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Execute an Android service action."""
+    android_service = container.android_service()
+    broadcaster = get_status_broadcaster()
+    service_id, action = data["service_id"], data["action"]
+    node_id = data.get("node_id", f"android_{service_id}_{action}")
+
+    await broadcaster.update_node_status(node_id, "executing")
+    result = await android_service.execute_service(
+        node_id=node_id, service_id=service_id, action=action,
+        parameters=data.get("parameters", {}),
+        android_host=data.get("android_host", "localhost"),
+        android_port=data.get("android_port", 8888)
+    )
+
+    status = "success" if result.get("success") else "error"
+    await broadcaster.update_node_status(node_id, status, result.get("result") or {"error": result.get("error")})
+    return result
+
+
+@ws_handler()
+async def handle_setup_android_device(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Setup Android device connection."""
+    workflow_service = container.workflow_service()
+    broadcaster = get_status_broadcaster()
+    connection_type = data.get("connection_type", "local")
+
+    result = await workflow_service.execute_node(
+        node_id=data.get("node_id", "android_setup"),
+        node_type="androidDeviceSetup",
+        parameters={
+            "connection_type": connection_type,
+            "device_id": data.get("device_id", ""),
+            "websocket_url": data.get("websocket_url", ""),
+            "port": data.get("port", 8888),
+            "auto_forward": data.get("auto_forward", True)
+        }
+    )
+
+    if result.get("success"):
+        info = result.get("result", {})
+        has_device = info.get("has_real_device", False)
+        await broadcaster.update_android_status(
+            connected=has_device,
+            device_id=info.get("android_device") if has_device else None,
+            connected_devices=info.get("connected_devices", []),
+            connection_type=connection_type if has_device else "proxy_only"
+        )
+    return result
+
+
+@ws_handler()
+async def handle_android_relay_connect(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Connect to Android relay server.
+
+    Establishes WebSocket connection to relay server and broadcasts QR code for pairing.
+    Status updates are automatically broadcast via the relay client's broadcaster integration.
+    """
+    from services.android import get_relay_client
+
+    url = data.get("url", "")
+    api_key = data.get("api_key")
+
+    if not url:
+        return {
+            "success": False,
+            "connected": False,
+            "error": "Relay URL is required"
+        }
+
+    if not api_key:
+        return {
+            "success": False,
+            "connected": False,
+            "error": "API key is required"
+        }
+
+    logger.info(f"[WebSocket] Android relay connect: {url}")
+
+    try:
+        client, error = await get_relay_client(url, api_key)
+        if client:
+            return {
+                "success": True,
+                "connected": True,
+                "session_token": client.session_token,
+                "qr_data": client.qr_data,
+                "message": "Connected to relay server"
+            }
+        else:
+            return {
+                "success": False,
+                "connected": False,
+                "error": error or "Failed to connect to relay server"
+            }
+    except Exception as e:
+        logger.error(f"[WebSocket] Android relay connect error: {e}")
+        return {"success": False, "error": str(e)}
+
+
+@ws_handler()
+async def handle_android_relay_disconnect(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Disconnect from Android relay server.
+
+    Closes the relay WebSocket connection and broadcasts disconnected status.
+    """
+    from services.android import close_relay_client
+
+    logger.info("[WebSocket] Android relay disconnect requested")
+
+    try:
+        await close_relay_client()
+        return {
+            "success": True,
+            "connected": False,
+            "message": "Disconnected from relay server"
+        }
+    except Exception as e:
+        logger.error(f"[WebSocket] Android relay disconnect error: {e}")
+        return {"success": False, "error": str(e)}
+
+
+@ws_handler()
+async def handle_android_relay_reconnect(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Reconnect to Android relay server with a new session token.
+
+    Forces disconnect and reconnect to get fresh session_token and QR code.
+    Useful when pairing fails or Android device needs to re-pair.
+    """
+    from services.android import close_relay_client, get_relay_client
+
+    url = data.get("url", "")
+    api_key = data.get("api_key")
+
+    if not url:
+        return {
+            "success": False,
+            "connected": False,
+            "error": "Relay URL is required"
+        }
+
+    if not api_key:
+        return {
+            "success": False,
+            "connected": False,
+            "error": "API key is required"
+        }
+
+    logger.info("[WebSocket] Android relay reconnect: forcing new session")
+
+    try:
+        # Force disconnect existing connection
+        await close_relay_client()
+
+        # Small delay to ensure clean disconnect
+        await asyncio.sleep(0.5)
+
+        # Reconnect with fresh session
+        client, error = await get_relay_client(url, api_key)
+        if client:
+            return {
+                "success": True,
+                "connected": True,
+                "session_token": client.session_token,
+                "qr_data": client.qr_data,
+                "message": "Reconnected with new session token"
+            }
+        else:
+            return {
+                "success": False,
+                "connected": False,
+                "error": error or "Failed to reconnect to relay server"
+            }
+    except Exception as e:
+        logger.error(f"[WebSocket] Android relay reconnect error: {e}")
+        return {"success": False, "error": str(e)}
+
+
+# ============================================================================
+# Maps Handlers
+# ============================================================================
+
+async def handle_validate_maps_key(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Validate Google Maps API key and save to database if valid."""
+    import httpx
+    broadcaster = get_status_broadcaster()
+    auth_service = container.auth_service()
+
+    api_key = data.get("api_key", "").strip()
+    session_id = data.get("session_id", "default")
+
+    if not api_key:
+        return {"success": False, "valid": False, "error": "api_key required"}
+
+    try:
+        # Test the API key with a simple geocoding request
+        async with httpx.AsyncClient() as client:
+            response = await client.get(
+                "https://maps.googleapis.com/maps/api/geocode/json",
+                params={
+                    "address": "1600 Amphitheatre Parkway, Mountain View, CA",
+                    "key": api_key
+                },
+                timeout=10.0
+            )
+
+            response_data = response.json()
+
+            if response_data.get("status") == "OK":
+                # Save the validated key to database
+                await auth_service.store_api_key(
+                    provider="google_maps",
+                    api_key=api_key,
+                    models=[],
+                    session_id=session_id
+                )
+                await broadcaster.update_api_key_status(
+                    provider="google_maps",
+                    valid=True,
+                    message="API key validated successfully"
+                )
+                return {"success": True, "valid": True, "message": "Google Maps API key is valid"}
+
+            elif response_data.get("status") == "REQUEST_DENIED":
+                error_msg = response_data.get("error_message", "Invalid API key")
+                await broadcaster.update_api_key_status(
+                    provider="google_maps",
+                    valid=False,
+                    message=error_msg
+                )
+                return {"success": True, "valid": False, "message": error_msg}
+
+            else:
+                # Other statuses like ZERO_RESULTS still mean the key works
+                # Save the validated key to database
+                await auth_service.store_api_key(
+                    provider="google_maps",
+                    api_key=api_key,
+                    models=[],
+                    session_id=session_id
+                )
+                await broadcaster.update_api_key_status(
+                    provider="google_maps",
+                    valid=True,
+                    message="API key validated"
+                )
+                return {"success": True, "valid": True, "message": f"API key is valid (status: {response_data.get('status')})"}
+
+    except httpx.TimeoutException:
+        await broadcaster.update_api_key_status(
+            provider="google_maps",
+            valid=False,
+            message="Validation request timed out"
+        )
+        return {"success": False, "valid": False, "error": "Validation request timed out"}
+
+    except Exception as e:
+        logger.error("Maps key validation failed", error=str(e))
+        await broadcaster.update_api_key_status(
+            provider="google_maps",
+            valid=False,
+            message=str(e)
+        )
+        return {"success": False, "valid": False, "error": str(e)}
+
+
+# ============================================================================
+# WhatsApp Handlers - Wrappers for routers.whatsapp functions
+# ============================================================================
+
+from routers.whatsapp import (
+    handle_whatsapp_status as _wa_status,
+    handle_whatsapp_qr as _wa_qr,
+    handle_whatsapp_send as _wa_send,
+    handle_whatsapp_start as _wa_start,
+    handle_whatsapp_restart as _wa_restart,
+    handle_whatsapp_groups as _wa_groups,
+    handle_whatsapp_group_info as _wa_group_info,
+    handle_whatsapp_chat_history as _wa_chat_history,
+)
+
+
+async def handle_whatsapp_status(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    return await _wa_status()
+
+
+async def handle_whatsapp_qr(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    return await _wa_qr()
+
+
+async def handle_whatsapp_send(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Forward all send params to WhatsApp handler - supports all message types."""
+    return await _wa_send(data)
+
+
+async def handle_whatsapp_start(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    return await _wa_start()
+
+
+async def handle_whatsapp_restart(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    return await _wa_restart()
+
+
+async def handle_whatsapp_groups(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    return await _wa_groups()
+
+
+async def handle_whatsapp_group_info(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get group participants with resolved phone numbers."""
+    group_id = data.get("group_id", "")
+    return await _wa_group_info(group_id)
+
+
+async def handle_whatsapp_chat_history(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get chat history from WhatsApp history store."""
+    return await _wa_chat_history(data)
+
+
+# ============================================================================
+# Workflow Storage Operations
+# ============================================================================
+
+async def handle_save_workflow(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Save workflow to database."""
+    database = container.database()
+    success = await database.save_workflow(
+        workflow_id=data["workflow_id"],
+        name=data["name"],
+        data=data.get("data", {})
+    )
+    return {"success": success, "workflow_id": data["workflow_id"]}
+
+
+async def handle_get_workflow(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get workflow by ID."""
+    database = container.database()
+    workflow = await database.get_workflow(data["workflow_id"])
+    if workflow:
+        return {
+            "success": True,
+            "workflow": {
+                "id": workflow.id,
+                "name": workflow.name,
+                "data": workflow.data,
+                "created_at": workflow.created_at.isoformat() if workflow.created_at else None,
+                "updated_at": workflow.updated_at.isoformat() if workflow.updated_at else None
+            }
+        }
+    return {"success": False, "error": "Workflow not found"}
+
+
+async def handle_get_all_workflows(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get all workflows."""
+    database = container.database()
+    workflows = await database.get_all_workflows()
+    return {
+        "success": True,
+        "workflows": [
+            {
+                "id": w.id,
+                "name": w.name,
+                "nodeCount": len(w.data.get("nodes", [])) if w.data else 0,
+                "created_at": w.created_at.isoformat() if w.created_at else None,
+                "updated_at": w.updated_at.isoformat() if w.updated_at else None
+            }
+            for w in workflows
+        ]
+    }
+
+
+async def handle_delete_workflow(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Delete workflow."""
+    database = container.database()
+    success = await database.delete_workflow(data["workflow_id"])
+    return {"success": success, "workflow_id": data["workflow_id"]}
+
+
+# ============================================================================
+# Chat Message Handler (for chatTrigger nodes)
+# ============================================================================
+
+@ws_handler("message")
+async def handle_send_chat_message(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Handle chat message from console panel - dispatches to chatTrigger nodes.
+
+    This handler receives messages from the frontend chat panel and dispatches
+    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
+
+    message = data["message"]
+    role = data.get("role", "user")
+    session_id = data.get("session_id", "default")
+    timestamp = data.get("timestamp") or datetime.now().isoformat()
+
+    # Save to database for persistence
+    database = container.database()
+    await database.add_chat_message(session_id, role, message)
+
+    # Build event data matching chatTrigger output schema
+    event_data = {
+        "message": message,
+        "timestamp": timestamp,
+        "session_id": session_id
+    }
+
+    # Dispatch to chatTrigger waiters
+    resolved = event_waiter.dispatch("chat_message_received", event_data)
+
+    logger.info(f"[ChatMessage] Dispatched message to {resolved} chatTrigger waiter(s)")
+
+    return {
+        "success": True,
+        "message": "Chat message sent",
+        "resolved_count": resolved,
+        "timestamp": timestamp
+    }
+
+
+@ws_handler()
+async def handle_get_chat_messages(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get chat messages from database for a session."""
+    session_id = data.get("session_id", "default")
+    limit = data.get("limit")  # Optional limit
+
+    database = container.database()
+    messages = await database.get_chat_messages(session_id, limit)
+
+    return {
+        "success": True,
+        "messages": messages,
+        "session_id": session_id
+    }
+
+
+@ws_handler()
+async def handle_clear_chat_messages(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Clear all chat messages for a session."""
+    session_id = data.get("session_id", "default")
+
+    database = container.database()
+    count = await database.clear_chat_messages(session_id)
+
+    return {
+        "success": True,
+        "message": f"Cleared {count} chat messages",
+        "cleared_count": count
+    }
+
+
+@ws_handler("message", "role")
+async def handle_save_chat_message(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Save a single chat message (used for assistant responses)."""
+    message = data["message"]
+    role = data["role"]
+    session_id = data.get("session_id", "default")
+
+    database = container.database()
+    success = await database.add_chat_message(session_id, role, message)
+
+    return {
+        "success": success,
+        "message": "Chat message saved" if success else "Failed to save chat message"
+    }
+
+
+@ws_handler()
+async def handle_get_chat_sessions(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get list of all chat sessions."""
+    database = container.database()
+    sessions = await database.get_chat_sessions()
+
+    return {
+        "success": True,
+        "sessions": sessions
+    }
+
+
+# ============================================================================
+# Terminal Logs Handlers
+# ============================================================================
+
+@ws_handler()
+async def handle_get_terminal_logs(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get terminal log history."""
+    broadcaster = get_status_broadcaster()
+    logs = broadcaster.get_terminal_logs()
+    return {"success": True, "logs": logs}
+
+
+@ws_handler()
+async def handle_clear_terminal_logs(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Clear terminal log history."""
+    broadcaster = get_status_broadcaster()
+    await broadcaster.clear_terminal_logs()
+    return {"success": True, "message": "Terminal logs cleared"}
+
+
+# ============================================================================
+# User Skills Handlers
+# ============================================================================
+
+@ws_handler("skill_name")
+async def handle_get_skill_content(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get skill content (instructions) by skill name.
+
+    Works for both built-in skills (from SKILL.md files) and user skills (from database).
+    """
+    from services.skill_loader import get_skill_loader
+
+    skill_name = data["skill_name"]
+    skill_loader = get_skill_loader()
+
+    # Try to load the skill
+    skill = skill_loader.load_skill(skill_name)
+    if skill:
+        return {
+            "success": True,
+            "skill_name": skill_name,
+            "instructions": skill.instructions,
+            "description": skill.metadata.description,
+            "allowed_tools": skill.metadata.allowed_tools,
+            "is_builtin": skill.metadata.path is not None,
+            "timestamp": time.time()
+        }
+
+    # Try loading from database for user skills
+    database = container.database()
+    user_skill = await database.get_user_skill(skill_name)
+    if user_skill:
+        return {
+            "success": True,
+            "skill_name": skill_name,
+            "instructions": user_skill.instructions,
+            "description": user_skill.description,
+            "allowed_tools": user_skill.allowed_tools.split(',') if user_skill.allowed_tools else [],
+            "is_builtin": False,
+            "timestamp": time.time()
+        }
+
+    return {"success": False, "error": f"Skill '{skill_name}' not found"}
+
+
+@ws_handler("skill_name", "instructions")
+async def handle_save_skill_content(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Save skill content (instructions) by skill name.
+
+    For built-in skills, writes to the SKILL.md file.
+    For user skills, updates the database.
+    """
+    import re
+    from pathlib import Path
+    from services.skill_loader import get_skill_loader
+
+    skill_name = data["skill_name"]
+    new_instructions = data["instructions"]
+    skill_loader = get_skill_loader()
+
+    # Check if it's a built-in skill
+    if skill_name in skill_loader._registry:
+        metadata = skill_loader._registry[skill_name]
+        if metadata.path is not None:
+            # It's a built-in skill - update SKILL.md file
+            skill_md_path = metadata.path / "SKILL.md"
+
+            if not skill_md_path.exists():
+                return {"success": False, "error": f"SKILL.md not found for '{skill_name}'"}
+
+            # Read existing file to preserve frontmatter
+            content = skill_md_path.read_text(encoding='utf-8')
+
+            # Parse frontmatter
+            frontmatter_match = re.match(r'^(---\s*\n.*?\n---\s*\n)', content, re.DOTALL)
+            if frontmatter_match:
+                # Keep frontmatter, replace body
+                new_content = frontmatter_match.group(1) + new_instructions
+            else:
+                # No frontmatter, just write instructions
+                new_content = new_instructions
+
+            # Write back to file
+            skill_md_path.write_text(new_content, encoding='utf-8')
+
+            # Clear cache so next load gets fresh content
+            skill_loader.clear_cache()
+
+            logger.info(f"[Skills] Updated built-in skill: {skill_name}")
+            return {
+                "success": True,
+                "skill_name": skill_name,
+                "is_builtin": True,
+                "message": f"Skill '{skill_name}' saved to SKILL.md",
+                "timestamp": time.time()
+            }
+
+    # It's a user skill - update in database
+    database = container.database()
+    user_skill = await database.get_user_skill(skill_name)
+    if user_skill:
+        updated = await database.update_user_skill(
+            name=skill_name,
+            instructions=new_instructions
+        )
+        if updated:
+            logger.info(f"[Skills] Updated user skill: {skill_name}")
+            return {
+                "success": True,
+                "skill_name": skill_name,
+                "is_builtin": False,
+                "message": f"Skill '{skill_name}' saved to database",
+                "timestamp": time.time()
+            }
+
+    return {"success": False, "error": f"Skill '{skill_name}' not found"}
+
+
+@ws_handler()
+async def handle_get_user_skills(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get all user-created skills."""
+    database = container.database()
+    active_only = data.get("active_only", True)
+    skills = await database.get_all_user_skills(active_only=active_only)
+    return {"skills": skills, "count": len(skills), "timestamp": time.time()}
+
+
+@ws_handler("name")
+async def handle_get_user_skill(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get a specific user skill by name."""
+    database = container.database()
+    skill = await database.get_user_skill(data["name"])
+    if skill:
+        return {"skill": skill, "timestamp": time.time()}
+    return {"success": False, "error": f"Skill '{data['name']}' not found"}
+
+
+@ws_handler("name", "display_name", "description", "instructions")
+async def handle_create_user_skill(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Create a new user skill."""
+    database = container.database()
+    broadcaster = get_status_broadcaster()
+
+    skill = await database.create_user_skill(
+        name=data["name"],
+        display_name=data["display_name"],
+        description=data["description"],
+        instructions=data["instructions"],
+        allowed_tools=data.get("allowed_tools"),
+        category=data.get("category", "custom"),
+        icon=data.get("icon", "star"),
+        color=data.get("color", "#6366F1"),
+        metadata_json=data.get("metadata"),
+        created_by=data.get("created_by")
+    )
+
+    if skill:
+        # Broadcast skill created to all clients
+        await broadcaster.broadcast({
+            "type": "user_skill_created",
+            "skill": skill,
+            "timestamp": time.time()
+        })
+        return {"skill": skill, "timestamp": time.time()}
+    return {"success": False, "error": f"Failed to create skill. Name '{data['name']}' may already exist."}
+
+
+@ws_handler("name")
+async def handle_update_user_skill(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Update an existing user skill."""
+    database = container.database()
+    broadcaster = get_status_broadcaster()
+
+    skill = await database.update_user_skill(
+        name=data["name"],
+        display_name=data.get("display_name"),
+        description=data.get("description"),
+        instructions=data.get("instructions"),
+        allowed_tools=data.get("allowed_tools"),
+        category=data.get("category"),
+        icon=data.get("icon"),
+        color=data.get("color"),
+        metadata_json=data.get("metadata"),
+        is_active=data.get("is_active")
+    )
+
+    if skill:
+        # Broadcast skill updated to all clients
+        await broadcaster.broadcast({
+            "type": "user_skill_updated",
+            "skill": skill,
+            "timestamp": time.time()
+        })
+        return {"skill": skill, "timestamp": time.time()}
+    return {"success": False, "error": f"Skill '{data['name']}' not found"}
+
+
+@ws_handler("name")
+async def handle_delete_user_skill(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Delete a user skill."""
+    database = container.database()
+    broadcaster = get_status_broadcaster()
+
+    deleted = await database.delete_user_skill(data["name"])
+
+    if deleted:
+        # Broadcast skill deleted to all clients
+        await broadcaster.broadcast({
+            "type": "user_skill_deleted",
+            "name": data["name"],
+            "timestamp": time.time()
+        })
+        return {"deleted": True, "name": data["name"], "timestamp": time.time()}
+    return {"success": False, "error": f"Skill '{data['name']}' not found"}
+
+
+# ============================================================================
+# Message Router
+# ============================================================================
+
+MESSAGE_HANDLERS: Dict[str, MessageHandler] = {
+    # Status/ping
+    "ping": handle_ping,
+    "get_status": handle_get_status,
+    "get_android_status": handle_get_android_status,
+    "get_node_status": handle_get_node_status,
+    "get_variable": handle_get_variable,
+
+    # Node parameters
+    "get_node_parameters": handle_get_node_parameters,
+    "get_all_node_parameters": handle_get_all_node_parameters,
+    "save_node_parameters": handle_save_node_parameters,
+    "delete_node_parameters": handle_delete_node_parameters,
+
+    # Tool schemas (source of truth for tool configurations)
+    "get_tool_schema": handle_get_tool_schema,
+    "save_tool_schema": handle_save_tool_schema,
+    "delete_tool_schema": handle_delete_tool_schema,
+    "get_all_tool_schemas": handle_get_all_tool_schemas,
+
+    # Node execution
+    "execute_node": handle_execute_node,
+    "execute_workflow": handle_execute_workflow,
+    "cancel_execution": handle_cancel_execution,
+    "get_node_output": handle_get_node_output,
+    "clear_node_output": handle_clear_node_output,
+
+    # Trigger/event waiting
+    "cancel_event_wait": handle_cancel_event_wait,
+    "get_active_waiters": handle_get_active_waiters,
+
+    # Dead Letter Queue (DLQ) operations
+    "get_dlq_entries": handle_get_dlq_entries,
+    "get_dlq_entry": handle_get_dlq_entry,
+    "get_dlq_stats": handle_get_dlq_stats,
+    "replay_dlq_entry": handle_replay_dlq_entry,
+    "remove_dlq_entry": handle_remove_dlq_entry,
+    "purge_dlq": handle_purge_dlq,
+
+    # Deployment operations
+    "deploy_workflow": handle_deploy_workflow,
+    "cancel_deployment": handle_cancel_deployment,
+    "get_deployment_status": handle_get_deployment_status,
+    "get_workflow_lock": handle_get_workflow_lock,
+    "update_deployment_settings": handle_update_deployment_settings,
+
+    # AI operations
+    "execute_ai_node": handle_execute_ai_node,
+    "get_ai_models": handle_get_ai_models,
+
+    # API key operations
+    "validate_api_key": handle_validate_api_key,
+    "get_stored_api_key": handle_get_stored_api_key,
+    "save_api_key": handle_save_api_key,
+    "delete_api_key": handle_delete_api_key,
+
+    # Android operations
+    "get_android_devices": handle_get_android_devices,
+    "execute_android_action": handle_execute_android_action,
+    "setup_android_device": handle_setup_android_device,
+    "android_relay_connect": handle_android_relay_connect,
+    "android_relay_disconnect": handle_android_relay_disconnect,
+    "android_relay_reconnect": handle_android_relay_reconnect,
+
+    # Maps operations
+    "validate_maps_key": handle_validate_maps_key,
+
+    # WhatsApp operations
+    "whatsapp_status": handle_whatsapp_status,
+    "whatsapp_qr": handle_whatsapp_qr,
+    "whatsapp_send": handle_whatsapp_send,
+    "whatsapp_start": handle_whatsapp_start,
+    "whatsapp_restart": handle_whatsapp_restart,
+    "whatsapp_groups": handle_whatsapp_groups,
+    "whatsapp_group_info": handle_whatsapp_group_info,
+    "whatsapp_chat_history": handle_whatsapp_chat_history,
+
+    # Workflow storage operations
+    "save_workflow": handle_save_workflow,
+    "get_workflow": handle_get_workflow,
+    "get_all_workflows": handle_get_all_workflows,
+    "delete_workflow": handle_delete_workflow,
+
+    # Chat message (for chatTrigger nodes)
+    "send_chat_message": handle_send_chat_message,
+    "get_chat_messages": handle_get_chat_messages,
+    "clear_chat_messages": handle_clear_chat_messages,
+    "save_chat_message": handle_save_chat_message,
+
+    # Terminal logs
+    "get_terminal_logs": handle_get_terminal_logs,
+    "clear_terminal_logs": handle_clear_terminal_logs,
+
+    # User Skills
+    "get_user_skills": handle_get_user_skills,
+    "get_user_skill": handle_get_user_skill,
+    "create_user_skill": handle_create_user_skill,
+    "update_user_skill": handle_update_user_skill,
+    "delete_user_skill": handle_delete_user_skill,
+
+    # Skill Content (built-in and user skills)
+    "get_skill_content": handle_get_skill_content,
+    "save_skill_content": handle_save_skill_content,
+}
+
+
+async def _execute_handler(
+    handler: MessageHandler,
+    data: Dict[str, Any],
+    websocket: WebSocket,
+    msg_type: str,
+    request_id: Optional[str]
+):
+    """Execute handler and send response using safe send."""
+    try:
+        result = await handler(data, websocket)
+
+        if request_id:
+            await _safe_send(websocket, {
+                "type": f"{msg_type}_result",
+                "request_id": request_id,
+                **result
+            })
+        else:
+            await _safe_send(websocket, result)
+
+    except asyncio.CancelledError:
+        # Task was cancelled (e.g., WebSocket disconnected)
+        logger.debug(f"[WebSocket] Handler cancelled: {msg_type}")
+        raise
+    except Exception as e:
+        logger.error("Handler error", msg_type=msg_type, error=str(e))
+        if request_id:
+            await _safe_send(websocket, {
+                "type": f"{msg_type}_result",
+                "request_id": request_id,
+                "success": False,
+                "error": str(e)
+            })
+
+
+@router.websocket("/ws/status")
+async def websocket_status_endpoint(websocket: WebSocket):
+    """WebSocket endpoint for real-time bidirectional communication.
+
+    Uses decoupled receive/process pattern with asyncio.Queue:
+    - Receive task: continuously receives messages into queue (never blocks)
+    - Process task: reads from queue and spawns handler tasks (can be long-running)
+
+    This ensures cancel messages are always processed immediately, even when
+    long-running handlers (like trigger node execution) are active.
+
+    All client requests include a request_id for correlation.
+    The server responds with the same request_id for request/response matching.
+    Broadcasts (without request_id) are sent to all connected clients.
+    """
+    # Authenticate via cookie before accepting connection
+    settings = container.settings()
+
+    # Check if auth is disabled (VITE_AUTH_ENABLED=false)
+    auth_disabled = settings.vite_auth_enabled and settings.vite_auth_enabled.lower() == 'false'
+
+    if not auth_disabled:
+        # Auth enabled - verify token
+        token = websocket.cookies.get(settings.jwt_cookie_name)
+
+        if not token:
+            await websocket.close(code=4001, reason="Not authenticated")
+            return
+
+        user_auth = container.user_auth_service()
+        payload = user_auth.verify_token(token)
+
+        if not payload:
+            await websocket.close(code=4001, reason="Invalid or expired session")
+            return
+
+    broadcaster = get_status_broadcaster()
+    await broadcaster.connect(websocket)
+
+    # Message queue for decoupling receive from processing
+    message_queue: asyncio.Queue = asyncio.Queue()
+
+    # Track handler tasks for this WebSocket
+    handler_tasks: Set[asyncio.Task] = set()
+    _handler_tasks[websocket] = handler_tasks
+
+    async def receive_loop():
+        """Receives messages and puts them in queue - never blocks on handlers."""
+        try:
+            while True:
+                data = await websocket.receive_json()
+                await message_queue.put(data)
+        except WebSocketDisconnect:
+            # Don't log here - logging during shutdown can raise KeyboardInterrupt
+            await message_queue.put(None)  # Signal shutdown
+        except asyncio.CancelledError:
+            # Task cancelled during shutdown - this is expected
+            await message_queue.put(None)
+            raise
+        except Exception as e:
+            # Only log if it's not a shutdown-related error
+            if not isinstance(e, (KeyboardInterrupt, SystemExit)):
+                logger.error(f"[WebSocket] Receive error: {e}")
+            await message_queue.put(None)
+
+    async def process_loop():
+        """Processes messages from queue - spawns handler tasks that can run concurrently."""
+        while True:
+            data = await message_queue.get()
+
+            if data is None:  # Shutdown signal
+                break
+
+            msg_type = data.get("type", "")
+            request_id = data.get("request_id")
+
+            logger.debug("WebSocket message received", msg_type=msg_type, has_request_id=bool(request_id))
+
+            handler = MESSAGE_HANDLERS.get(msg_type)
+
+            if handler:
+                # Run handler as task so it doesn't block queue processing
+                # This allows cancel_event_wait to be processed while execute_node is waiting
+                task = asyncio.create_task(
+                    _execute_handler(handler, data, websocket, msg_type, request_id)
+                )
+                handler_tasks.add(task)
+                task.add_done_callback(handler_tasks.discard)
+            else:
+                logger.warning("Unknown message type", msg_type=msg_type)
+                if request_id:
+                    await _safe_send(websocket, {
+                        "type": "error",
+                        "request_id": request_id,
+                        "code": "UNKNOWN_MESSAGE_TYPE",
+                        "message": f"Unknown message type: {msg_type}"
+                    })
+
+    try:
+        # Run receive and process loops concurrently using TaskGroup (Python 3.11+)
+        async with asyncio.TaskGroup() as tg:
+            tg.create_task(receive_loop())
+            tg.create_task(process_loop())
+
+    except* WebSocketDisconnect:
+        pass  # Normal disconnect - don't log during shutdown
+    except* asyncio.CancelledError:
+        pass  # Task cancelled during shutdown - expected
+    except* (KeyboardInterrupt, SystemExit):
+        pass  # Server shutdown - don't log
+    except* Exception as eg:
+        for exc in eg.exceptions:
+            if not isinstance(exc, (WebSocketDisconnect, asyncio.CancelledError, KeyboardInterrupt, SystemExit)):
+                logger.error(f"[WebSocket] TaskGroup error: {exc}")
+    finally:
+        # Cancel any running handler tasks on disconnect
+        for task in list(handler_tasks):
+            if not task.done():
+                task.cancel()
+
+        # Wait for tasks to finish cancellation
+        if handler_tasks:
+            await asyncio.gather(*handler_tasks, return_exceptions=True)
+
+        # Cleanup
+        _handler_tasks.pop(websocket, None)
+        await broadcaster.disconnect(websocket)
+
+
+@router.websocket("/ws/internal")
+async def websocket_internal_endpoint(websocket: WebSocket):
+    """Internal WebSocket endpoint for Temporal workers.
+
+    This endpoint bypasses authentication and is intended for internal
+    service-to-service communication (e.g., Temporal activity -> MachinaOs).
+
+    Security: Should only be exposed on localhost/internal network.
+    """
+    broadcaster = get_status_broadcaster()
+    await websocket.accept()
+
+    logger.info("[WebSocket Internal] Temporal worker connected")
+
+    # Message queue for decoupling receive from processing
+    message_queue: asyncio.Queue = asyncio.Queue()
+
+    # Track handler tasks for this WebSocket
+    handler_tasks: Set[asyncio.Task] = set()
+
+    async def receive_loop():
+        """Receives messages and puts them in queue."""
+        try:
+            while True:
+                data = await websocket.receive_json()
+                await message_queue.put(data)
+        except WebSocketDisconnect:
+            await message_queue.put(None)
+        except asyncio.CancelledError:
+            await message_queue.put(None)
+            raise
+        except Exception as e:
+            if not isinstance(e, (KeyboardInterrupt, SystemExit)):
+                logger.error(f"[WebSocket Internal] Receive error: {e}")
+            await message_queue.put(None)
+
+    async def process_loop():
+        """Processes messages from queue."""
+        while True:
+            data = await message_queue.get()
+
+            if data is None:
+                break
+
+            msg_type = data.get("type", "")
+            request_id = data.get("request_id")
+
+            handler = MESSAGE_HANDLERS.get(msg_type)
+
+            if handler:
+                task = asyncio.create_task(
+                    _execute_handler(handler, data, websocket, msg_type, request_id)
+                )
+                handler_tasks.add(task)
+                task.add_done_callback(handler_tasks.discard)
+            else:
+                logger.warning(f"[WebSocket Internal] Unknown message type: {msg_type}")
+                if request_id:
+                    await _safe_send(websocket, {
+                        "type": "error",
+                        "request_id": request_id,
+                        "code": "UNKNOWN_MESSAGE_TYPE",
+                        "message": f"Unknown message type: {msg_type}"
+                    })
+
+    try:
+        async with asyncio.TaskGroup() as tg:
+            tg.create_task(receive_loop())
+            tg.create_task(process_loop())
+
+    except* WebSocketDisconnect:
+        pass  # Normal disconnect
+    except* asyncio.CancelledError:
+        pass  # Task cancelled during shutdown
+    except* (KeyboardInterrupt, SystemExit):
+        pass  # Server shutdown
+    except* Exception as eg:
+        for exc in eg.exceptions:
+            if not isinstance(exc, (WebSocketDisconnect, asyncio.CancelledError, KeyboardInterrupt, SystemExit)):
+                logger.error(f"[WebSocket Internal] TaskGroup error: {exc}")
+    finally:
+        for task in list(handler_tasks):
+            if not task.done():
+                task.cancel()
+
+        if handler_tasks:
+            await asyncio.gather(*handler_tasks, return_exceptions=True)
+
+
+@router.get("/ws/info")
+async def websocket_info():
+    """Get WebSocket connection info."""
+    broadcaster = get_status_broadcaster()
+    return {
+        "endpoint": "/ws/status",
+        "connected_clients": broadcaster.connection_count,
+        "current_status": broadcaster.get_status(),
+        "supported_message_types": list(MESSAGE_HANDLERS.keys())
+    }