machinaos 0.0.78 → 0.0.80

package/server/nodes/whatsapp/_base.py

@@ -17,7 +17,7 @@ logger = get_logger(__name__)
 
 def _is_invite_link(value: str) -> bool:
     """Check if a channel identifier is an invite link URL."""
-    return value.strip().startswith('http://') or value.strip().startswith('https://')
+    return value.strip().startswith("http://") or value.strip().startswith("https://")
 
 
 def _resolve_channel_identifier(value: str) -> Dict[str, str]:
@@ -30,8 +30,8 @@ def _resolve_channel_identifier(value: str) -> Dict[str, str]:
         return {}
     value = value.strip()
     if _is_invite_link(value):
-        return {'invite': value}
-    return {'jid': value}
+        return {"invite": value}
+    return {"jid": value}
 
 
 async def _resolve_to_jid(value: str, rpc_call) -> str:
@@ -48,44 +48,40 @@ async def _resolve_to_jid(value: str, rpc_call) -> str:
     if not _is_invite_link(value):
         return value
     # Resolve invite link to JID via newsletter_info
-    data = await rpc_call('newsletter_info', {'invite': value})
+    data = await rpc_call("newsletter_info", {"invite": value})
     if isinstance(data, dict):
-        result = data.get('result', data)
-        jid = result.get('jid') or result.get('id')
+        result = data.get("result", data)
+        jid = result.get("jid") or result.get("id")
         if jid:
             return jid
     raise ValueError(f"Could not resolve invite link to channel JID: {value}")
 
 
 # Media types that can be downloaded via the media RPC
-MEDIA_MESSAGE_TYPES = frozenset({'image', 'video', 'audio', 'document', 'sticker'})
+MEDIA_MESSAGE_TYPES = frozenset({"image", "video", "audio", "document", "sticker"})
 
 
 async def _download_single_media(message: Dict[str, Any], rpc_call) -> None:
     """Download media for a single message in-place. Mutates the message dict."""
-    message_id = message.get('message_id') or message.get('id')
+    message_id = message.get("message_id") or message.get("id")
     if not message_id:
         return
     try:
-        data = await rpc_call('media', {'message_id': message_id})
+        data = await rpc_call("media", {"message_id": message_id})
         if isinstance(data, dict):
-            result = data.get('result', data)
-            if result.get('data'):
-                message['media_data'] = result['data']
-                message['media_mime_type'] = result.get('mime_type', '')
+            result = data.get("result", data)
+            if result.get("data"):
+                message["media_data"] = result["data"]
+                message["media_mime_type"] = result.get("mime_type", "")
             else:
-                message['media_error'] = result.get('error', 'No media data returned')
+                message["media_error"] = result.get("error", "No media data returned")
         else:
-            message['media_error'] = 'Unexpected response format'
+            message["media_error"] = "Unexpected response format"
     except Exception as e:
-        message['media_error'] = str(e)
+        message["media_error"] = str(e)
 
 
-async def _enrich_messages_with_media(
-    messages: List[Dict[str, Any]],
-    rpc_call,
-    max_concurrent: int = 5
-) -> List[Dict[str, Any]]:
+async def _enrich_messages_with_media(messages: List[Dict[str, Any]], rpc_call, max_concurrent: int = 5) -> List[Dict[str, Any]]:
     """Download media for messages that contain media types.
 
     Uses asyncio.Semaphore for concurrency control and asyncio.gather
@@ -106,30 +102,19 @@ async def _enrich_messages_with_media(
             await _download_single_media(msg, rpc_call)
 
     # Filter to only media messages
-    media_messages = [
-        msg for msg in messages
-        if msg.get('message_type', msg.get('type', '')) in MEDIA_MESSAGE_TYPES
-    ]
+    media_messages = [msg for msg in messages if msg.get("message_type", msg.get("type", "")) in MEDIA_MESSAGE_TYPES]
 
     if not media_messages:
         return messages
 
     logger.info(f"Downloading media for {len(media_messages)} messages (max concurrent: {max_concurrent})")
 
-    await asyncio.gather(
-        *(download_with_semaphore(msg) for msg in media_messages),
-        return_exceptions=True
-    )
+    await asyncio.gather(*(download_with_semaphore(msg) for msg in media_messages), return_exceptions=True)
 
     return messages
 
 
-async def handle_whatsapp_send(
-    node_id: str,
-    node_type: str,
-    parameters: Dict[str, Any],
-    context: Dict[str, Any]
-) -> Dict[str, Any]:
+async def handle_whatsapp_send(node_id: str, node_type: str, parameters: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
     """Handle WhatsApp send message node via Go RPC service.
 
     Supports all message types: text, image, video, audio, document, sticker, location, contact
@@ -146,49 +131,51 @@ async def handle_whatsapp_send(
         Execution result dict
     """
     from nodes.whatsapp._service import handle_whatsapp_send as whatsapp_send_handler
+
     start_time = time.time()
 
     try:
         # Determine recipient (snake_case parameters)
-        recipient_type = parameters.get('recipient_type', 'self')
-        message_type = parameters.get('message_type', 'text')
+        recipient_type = parameters.get("recipient_type", "self")
+        message_type = parameters.get("message_type", "text")
 
         # Determine recipient based on type
-        if recipient_type == 'self':
+        if recipient_type == "self":
             # Self will be resolved by the router using connected phone
-            recipient = 'self'
-        elif recipient_type == 'channel':
-            recipient = parameters.get('channel_jid')
+            recipient = "self"
+        elif recipient_type == "channel":
+            recipient = parameters.get("channel_jid")
             if not recipient:
                 raise ValueError("Channel JID is required")
             # Validate channel-supported message types
-            channel_types = {'text', 'image', 'video', 'audio', 'document'}
+            channel_types = {"text", "image", "video", "audio", "document"}
             if message_type not in channel_types:
                 raise ValueError(f"Channels only support: {', '.join(sorted(channel_types))}. Got: {message_type}")
-        elif recipient_type == 'group':
-            recipient = parameters.get('group_id')
+        elif recipient_type == "group":
+            recipient = parameters.get("group_id")
             if not recipient:
                 raise ValueError("Group ID is required")
         else:  # phone
-            recipient = parameters.get('phone')
+            recipient = parameters.get("phone")
             if not recipient:
                 raise ValueError("Phone number is required")
 
         # For text messages, validate message content
-        if message_type == 'text' and not parameters.get('message'):
+        if message_type == "text" and not parameters.get("message"):
             raise ValueError("Message content is required for text messages")
 
         # Convert GFM markdown to WhatsApp-native formatting if enabled
-        if message_type == 'text' and parameters.get('format_markdown', False):
+        if message_type == "text" and parameters.get("format_markdown", False):
             from services.markdown_formatter import to_whatsapp
-            parameters['message'] = to_whatsapp(parameters['message'])
+
+            parameters["message"] = to_whatsapp(parameters["message"])
 
         # Call WhatsApp Go RPC service via handler - pass full params
         data = await whatsapp_send_handler(parameters)
 
-        success = data.get('success', False)
+        success = data.get("success", False)
         if not success:
-            raise Exception(data.get('error', 'Send failed'))
+            raise Exception(data.get("error", "Send failed"))
 
         # Build informative result based on message type (snake_case output)
         result = {
@@ -196,37 +183,37 @@ async def handle_whatsapp_send(
             "recipient": recipient,
             "recipient_type": recipient_type,
             "message_type": message_type,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         }
 
         # Add type-specific details using match statement
         match message_type:
-            case 'text':
-                msg_content = parameters.get('message', '')
+            case "text":
+                msg_content = parameters.get("message", "")
                 result["preview"] = msg_content[:100] + "..." if len(msg_content) > 100 else msg_content
-            case 'image' | 'video' | 'audio' | 'document' | 'sticker':
-                media_source = parameters.get('media_source', 'base64')
+            case "image" | "video" | "audio" | "document" | "sticker":
+                media_source = parameters.get("media_source", "base64")
                 result["media_source"] = media_source
-                if parameters.get('caption'):
-                    result["caption"] = parameters.get('caption')
-                if parameters.get('filename'):
-                    result["filename"] = parameters.get('filename')
-                if parameters.get('mime_type'):
-                    result["mime_type"] = parameters.get('mime_type')
+                if parameters.get("caption"):
+                    result["caption"] = parameters.get("caption")
+                if parameters.get("filename"):
+                    result["filename"] = parameters.get("filename")
+                if parameters.get("mime_type"):
+                    result["mime_type"] = parameters.get("mime_type")
                 # For file uploads, include the uploaded filename
-                file_param = parameters.get('file_path')
-                if isinstance(file_param, dict) and file_param.get('type') == 'upload':
-                    result["uploaded_file"] = file_param.get('filename')
-                    result["mime_type"] = file_param.get('mimeType')
-            case 'location':
+                file_param = parameters.get("file_path")
+                if isinstance(file_param, dict) and file_param.get("type") == "upload":
+                    result["uploaded_file"] = file_param.get("filename")
+                    result["mime_type"] = file_param.get("mimeType")
+            case "location":
                 result["location"] = {
-                    "latitude": parameters.get('latitude'),
-                    "longitude": parameters.get('longitude'),
-                    "name": parameters.get('location_name'),
-                    "address": parameters.get('address')
+                    "latitude": parameters.get("latitude"),
+                    "longitude": parameters.get("longitude"),
+                    "name": parameters.get("location_name"),
+                    "address": parameters.get("address"),
                 }
-            case 'contact':
-                result["contact_name"] = parameters.get('contact_name')
+            case "contact":
+                result["contact_name"] = parameters.get("contact_name")
 
         return {
             "success": success,
@@ -234,7 +221,7 @@ async def handle_whatsapp_send(
             "node_type": "whatsappSend",
             "result": result,
             "execution_time": time.time() - start_time,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         }
 
     except Exception as e:
@@ -245,16 +232,11 @@ async def handle_whatsapp_send(
             "node_type": "whatsappSend",
             "error": str(e),
             "execution_time": time.time() - start_time,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         }
 
 
-async def handle_whatsapp_db(
-    node_id: str,
-    node_type: str,
-    parameters: Dict[str, Any],
-    context: Dict[str, Any]
-) -> Dict[str, Any]:
+async def handle_whatsapp_db(node_id: str, node_type: str, parameters: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
     """Handle WhatsApp DB node - query contacts, groups, messages.
 
     Operations:
@@ -289,105 +271,103 @@ async def handle_whatsapp_db(
     Returns:
         Execution result dict
     """
-    from nodes.whatsapp._service import (
-        handle_whatsapp_chat_history as whatsapp_chat_history_handler,
-        whatsapp_rpc_call
-    )
+    from nodes.whatsapp._service import handle_whatsapp_chat_history as whatsapp_chat_history_handler, whatsapp_rpc_call
+
     start_time = time.time()
 
     try:
-        operation = parameters.get('operation', 'chat_history')
+        operation = parameters.get("operation", "chat_history")
 
-        if operation == 'chat_history':
+        if operation == "chat_history":
             return await _handle_chat_history(node_id, parameters, start_time, whatsapp_chat_history_handler, whatsapp_rpc_call)
-        elif operation == 'search_groups':
+        elif operation == "search_groups":
             return await _handle_search_groups(node_id, parameters, start_time, whatsapp_rpc_call)
-        elif operation == 'get_group_info':
+        elif operation == "get_group_info":
             return await _handle_get_group_info(node_id, parameters, start_time, whatsapp_rpc_call)
-        elif operation == 'get_contact_info':
+        elif operation == "get_contact_info":
             return await _handle_get_contact_info(node_id, parameters, start_time, whatsapp_rpc_call)
-        elif operation == 'list_contacts':
+        elif operation == "list_contacts":
             return await _handle_list_contacts(node_id, parameters, start_time, whatsapp_rpc_call)
-        elif operation == 'check_contacts':
+        elif operation == "check_contacts":
             return await _handle_check_contacts(node_id, parameters, start_time, whatsapp_rpc_call)
-        elif operation == 'list_channels':
+        elif operation == "list_channels":
             return await _handle_list_channels(node_id, parameters, start_time, whatsapp_rpc_call)
-        elif operation == 'get_channel_info':
+        elif operation == "get_channel_info":
             return await _handle_get_channel_info(node_id, parameters, start_time, whatsapp_rpc_call)
-        elif operation == 'channel_messages':
+        elif operation == "channel_messages":
             return await _handle_channel_messages(node_id, parameters, start_time, whatsapp_rpc_call)
-        elif operation == 'channel_stats':
+        elif operation == "channel_stats":
             return await _handle_channel_stats(node_id, parameters, start_time, whatsapp_rpc_call)
-        elif operation == 'channel_follow':
+        elif operation == "channel_follow":
             return await _handle_channel_follow(node_id, parameters, start_time, whatsapp_rpc_call)
-        elif operation == 'channel_unfollow':
+        elif operation == "channel_unfollow":
             return await _handle_channel_unfollow(node_id, parameters, start_time, whatsapp_rpc_call)
-        elif operation == 'channel_create':
+        elif operation == "channel_create":
             return await _handle_channel_create(node_id, parameters, start_time, whatsapp_rpc_call)
-        elif operation == 'channel_mute':
+        elif operation == "channel_mute":
             return await _handle_channel_mute(node_id, parameters, start_time, whatsapp_rpc_call)
-        elif operation == 'channel_mark_viewed':
+        elif operation == "channel_mark_viewed":
             return await _handle_channel_mark_viewed(node_id, parameters, start_time, whatsapp_rpc_call)
-        elif operation == 'newsletter_react':
+        elif operation == "newsletter_react":
             return await _handle_newsletter_react(node_id, parameters, start_time, whatsapp_rpc_call)
-        elif operation == 'newsletter_live_updates':
+        elif operation == "newsletter_live_updates":
             return await _handle_newsletter_live_updates(node_id, parameters, start_time, whatsapp_rpc_call)
-        elif operation == 'contact_profile_pic':
+        elif operation == "contact_profile_pic":
             return await _handle_contact_profile_pic(node_id, parameters, start_time, whatsapp_rpc_call)
         else:
             raise ValueError(f"Unknown operation: {operation}")
 
     except Exception as e:
-        logger.error("WhatsApp DB failed", node_id=node_id, operation=parameters.get('operation'), error=str(e))
+        logger.error("WhatsApp DB failed", node_id=node_id, operation=parameters.get("operation"), error=str(e))
         return {
             "success": False,
             "node_id": node_id,
             "node_type": "whatsappDb",
             "error": str(e),
             "execution_time": time.time() - start_time,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         }
 
 
 async def _handle_chat_history(node_id: str, parameters: Dict[str, Any], start_time: float, handler, rpc_call=None) -> Dict[str, Any]:
     """Handle chat_history operation."""
-    chat_type = parameters.get('chat_type', 'individual')
+    chat_type = parameters.get("chat_type", "individual")
     rpc_params: Dict[str, Any] = {}
 
-    if chat_type == 'individual':
-        phone = parameters.get('phone')
+    if chat_type == "individual":
+        phone = parameters.get("phone")
         if not phone:
             raise ValueError("Phone number is required for individual chats")
-        rpc_params['phone'] = phone
+        rpc_params["phone"] = phone
     else:
-        group_id = parameters.get('group_id')
+        group_id = parameters.get("group_id")
         if not group_id:
             raise ValueError("Group ID is required for group chats")
-        rpc_params['group_id'] = group_id
+        rpc_params["group_id"] = group_id
 
-        group_filter = parameters.get('group_filter', 'all')
-        if group_filter == 'contact':
-            sender_phone = parameters.get('sender_phone')
+        group_filter = parameters.get("group_filter", "all")
+        if group_filter == "contact":
+            sender_phone = parameters.get("sender_phone")
             if sender_phone:
-                rpc_params['sender_phone'] = sender_phone
+                rpc_params["sender_phone"] = sender_phone
 
-    message_filter = parameters.get('message_filter', 'all')
-    rpc_params['text_only'] = message_filter == 'text_only'
-    rpc_params['limit'] = parameters.get('limit', 50)
-    rpc_params['offset'] = parameters.get('offset', 0)
+    message_filter = parameters.get("message_filter", "all")
+    rpc_params["text_only"] = message_filter == "text_only"
+    rpc_params["limit"] = parameters.get("limit", 50)
+    rpc_params["offset"] = parameters.get("offset", 0)
 
     data = await handler(rpc_params)
 
-    if not data.get('success', False):
-        raise Exception(data.get('error', 'Failed to retrieve chat history'))
+    if not data.get("success", False):
+        raise Exception(data.get("error", "Failed to retrieve chat history"))
 
-    messages = data.get('messages', [])
-    base_offset = rpc_params.get('offset', 0)
+    messages = data.get("messages", [])
+    base_offset = rpc_params.get("offset", 0)
     for i, msg in enumerate(messages):
-        msg['index'] = base_offset + i + 1
+        msg["index"] = base_offset + i + 1
 
     # Enrich with media data if requested
-    if parameters.get('include_media_data') and rpc_call and messages:
+    if parameters.get("include_media_data") and rpc_call and messages:
         await _enrich_messages_with_media(messages, rpc_call)
 
     return {
@@ -397,41 +377,38 @@ async def _handle_chat_history(node_id: str, parameters: Dict[str, Any], start_t
         "result": {
             "operation": "chat_history",
             "messages": messages,
-            "total": data.get('total', 0),
-            "has_more": data.get('has_more', False),
+            "total": data.get("total", 0),
+            "has_more": data.get("has_more", False),
             "count": len(messages),
             "chat_type": chat_type,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         },
         "execution_time": time.time() - start_time,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
 
 
 async def _handle_search_groups(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
     """Handle search_groups operation."""
-    query = parameters.get('query', '')
-    limit = parameters.get('limit', 20)  # Default limit to prevent context overflow
-    data = await rpc_call('groups', {})
+    query = parameters.get("query", "")
+    limit = parameters.get("limit", 20)  # Default limit to prevent context overflow
+    data = await rpc_call("groups", {})
 
-    if not data.get('success', True):
-        raise Exception(data.get('error', 'Failed to get groups'))
+    if not data.get("success", True):
+        raise Exception(data.get("error", "Failed to get groups"))
 
-    groups = data if isinstance(data, list) else data.get('result', [])
+    groups = data if isinstance(data, list) else data.get("result", [])
 
     # Filter by query if provided
     if query:
         query_lower = query.lower()
-        groups = [g for g in groups if query_lower in g.get('name', '').lower()]
+        groups = [g for g in groups if query_lower in g.get("name", "").lower()]
 
     total_found = len(groups)
 
     # Apply limit to prevent context overflow (51 groups * ~4KB = 200KB+ tokens)
     # Only return essential fields: jid and name
-    groups_limited = [
-        {"jid": g.get("jid", ""), "name": g.get("name", "")}
-        for g in groups[:limit]
-    ]
+    groups_limited = [{"jid": g.get("jid", ""), "name": g.get("name", "")} for g in groups[:limit]]
 
     return {
         "success": True,
@@ -444,31 +421,33 @@ async def _handle_search_groups(node_id: str, parameters: Dict[str, Any], start_
             "returned": len(groups_limited),
             "has_more": total_found > limit,
             "query": query,
-            "hint": f"Showing {len(groups_limited)} of {total_found} groups. Use a more specific query or get_group_info for details." if total_found > limit else None,
-            "timestamp": datetime.now().isoformat()
+            "hint": f"Showing {len(groups_limited)} of {total_found} groups. Use a more specific query or get_group_info for details."
+            if total_found > limit
+            else None,
+            "timestamp": datetime.now().isoformat(),
         },
         "execution_time": time.time() - start_time,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
 
 
 async def _handle_get_group_info(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
     """Handle get_group_info operation."""
-    group_id = parameters.get('group_id_for_info') or parameters.get('group_id')
+    group_id = parameters.get("group_id_for_info") or parameters.get("group_id")
     if not group_id:
         raise ValueError("Group ID is required")
 
-    participant_limit = parameters.get('participant_limit', 50)  # Limit participants to prevent overflow
+    participant_limit = parameters.get("participant_limit", 50)  # Limit participants to prevent overflow
 
-    data = await rpc_call('group_info', {'group_id': group_id})
+    data = await rpc_call("group_info", {"group_id": group_id})
 
-    if not data.get('success', True) if isinstance(data, dict) else True:
-        raise Exception(data.get('error', 'Failed to get group info') if isinstance(data, dict) else 'Failed')
+    if not data.get("success", True) if isinstance(data, dict) else True:
+        raise Exception(data.get("error", "Failed to get group info") if isinstance(data, dict) else "Failed")
 
-    result = data if not isinstance(data, dict) or 'result' not in data else data.get('result', data)
+    result = data if not isinstance(data, dict) or "result" not in data else data.get("result", data)
 
     # Limit participants and return only essential fields
-    participants = result.get('participants', [])
+    participants = result.get("participants", [])
     total_participants = len(participants)
     participants_limited = [
         {"phone": p.get("phone", ""), "name": p.get("name", ""), "is_admin": p.get("is_admin", False)}
@@ -491,63 +470,52 @@ async def _handle_get_group_info(node_id: str, parameters: Dict[str, Any], start
         "success": True,
         "node_id": node_id,
         "node_type": "whatsappDb",
-        "result": {
-            "operation": "get_group_info",
-            **limited_result,
-            "timestamp": datetime.now().isoformat()
-        },
+        "result": {"operation": "get_group_info", **limited_result, "timestamp": datetime.now().isoformat()},
         "execution_time": time.time() - start_time,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
 
 
 async def _handle_get_contact_info(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
     """Handle get_contact_info operation."""
-    phone = parameters.get('contact_phone') or parameters.get('phone')
+    phone = parameters.get("contact_phone") or parameters.get("phone")
     if not phone:
         raise ValueError("Phone number is required")
 
-    data = await rpc_call('contact_info', {'phone': phone})
+    data = await rpc_call("contact_info", {"phone": phone})
 
-    if isinstance(data, dict) and not data.get('success', True):
-        raise Exception(data.get('error', 'Failed to get contact info'))
+    if isinstance(data, dict) and not data.get("success", True):
+        raise Exception(data.get("error", "Failed to get contact info"))
 
-    result = data if not isinstance(data, dict) or 'result' not in data else data.get('result', data)
+    result = data if not isinstance(data, dict) or "result" not in data else data.get("result", data)
 
     return {
         "success": True,
         "node_id": node_id,
         "node_type": "whatsappDb",
-        "result": {
-            "operation": "get_contact_info",
-            **result,
-            "timestamp": datetime.now().isoformat()
-        },
+        "result": {"operation": "get_contact_info", **result, "timestamp": datetime.now().isoformat()},
         "execution_time": time.time() - start_time,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
 
 
 async def _handle_list_contacts(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
     """Handle list_contacts operation."""
-    query = parameters.get('query', '')
-    limit = parameters.get('limit', 50)  # Default limit to prevent context overflow
+    query = parameters.get("query", "")
+    limit = parameters.get("limit", 50)  # Default limit to prevent context overflow
 
-    data = await rpc_call('contacts', {'query': query})
+    data = await rpc_call("contacts", {"query": query})
 
-    if isinstance(data, dict) and not data.get('success', True):
-        raise Exception(data.get('error', 'Failed to list contacts'))
+    if isinstance(data, dict) and not data.get("success", True):
+        raise Exception(data.get("error", "Failed to list contacts"))
 
-    result = data if not isinstance(data, dict) or 'result' not in data else data.get('result', data)
-    contacts = result.get('contacts', []) if isinstance(result, dict) else result
+    result = data if not isinstance(data, dict) or "result" not in data else data.get("result", data)
+    contacts = result.get("contacts", []) if isinstance(result, dict) else result
 
     total_found = len(contacts)
 
     # Apply limit and return only essential fields: phone, name, jid
-    contacts_limited = [
-        {"phone": c.get("phone", ""), "name": c.get("name", ""), "jid": c.get("jid", "")}
-        for c in contacts[:limit]
-    ]
+    contacts_limited = [{"phone": c.get("phone", ""), "name": c.get("name", ""), "jid": c.get("jid", "")} for c in contacts[:limit]]
 
     return {
         "success": True,
@@ -560,64 +528,61 @@ async def _handle_list_contacts(node_id: str, parameters: Dict[str, Any], start_
             "returned": len(contacts_limited),
             "has_more": total_found > limit,
             "query": query,
-            "hint": f"Showing {len(contacts_limited)} of {total_found} contacts. Use a more specific query to narrow results." if total_found > limit else None,
-            "timestamp": datetime.now().isoformat()
+            "hint": f"Showing {len(contacts_limited)} of {total_found} contacts. Use a more specific query to narrow results."
+            if total_found > limit
+            else None,
+            "timestamp": datetime.now().isoformat(),
         },
         "execution_time": time.time() - start_time,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
 
 
 async def _handle_check_contacts(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
     """Handle check_contacts operation."""
-    phones_str = parameters.get('phones', '')
+    phones_str = parameters.get("phones", "")
     if not phones_str:
         raise ValueError("Phone numbers are required")
 
     # Parse comma-separated phones
-    phones = [p.strip() for p in phones_str.split(',') if p.strip()]
+    phones = [p.strip() for p in phones_str.split(",") if p.strip()]
     if not phones:
         raise ValueError("At least one phone number is required")
 
-    data = await rpc_call('contact_check', {'phones': phones})
+    data = await rpc_call("contact_check", {"phones": phones})
 
-    if isinstance(data, dict) and not data.get('success', True):
-        raise Exception(data.get('error', 'Failed to check contacts'))
+    if isinstance(data, dict) and not data.get("success", True):
+        raise Exception(data.get("error", "Failed to check contacts"))
 
-    results = data if isinstance(data, list) else data.get('result', [])
+    results = data if isinstance(data, list) else data.get("result", [])
 
     return {
         "success": True,
         "node_id": node_id,
         "node_type": "whatsappDb",
-        "result": {
-            "operation": "check_contacts",
-            "results": results,
-            "total": len(results),
-            "timestamp": datetime.now().isoformat()
-        },
+        "result": {"operation": "check_contacts", "results": results, "total": len(results), "timestamp": datetime.now().isoformat()},
         "execution_time": time.time() - start_time,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
 
 
 async def _handle_contact_profile_pic(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
     """Handle contact_profile_pic operation - get profile picture for a contact/group."""
-    jid = parameters.get('profile_pic_jid') or parameters.get('phone')
+    jid = parameters.get("profile_pic_jid") or parameters.get("phone")
     if not jid:
         raise ValueError("JID or phone number is required")
 
-    rpc_params: Dict[str, Any] = {'jid': jid}
-    preview = parameters.get('preview', False)
+    rpc_params: Dict[str, Any] = {"jid": jid}
+    preview = parameters.get("preview", False)
     if preview:
-        rpc_params['preview'] = True
+        rpc_params["preview"] = True
 
-    data = await rpc_call('contact_profile_pic', rpc_params)
+    data = await rpc_call("contact_profile_pic", rpc_params)
 
-    if isinstance(data, dict) and not data.get('success', True):
-        raise Exception(data.get('error', 'Failed to get profile picture'))
+    if isinstance(data, dict) and not data.get("success", True):
+        raise Exception(data.get("error", "Failed to get profile picture"))
 
-    result = data if not isinstance(data, dict) or 'result' not in data else data.get('result', data)
+    result = data if not isinstance(data, dict) or "result" not in data else data.get("result", data)
 
     return {
         "success": True,
@@ -626,34 +591,33 @@ async def _handle_contact_profile_pic(node_id: str, parameters: Dict[str, Any],
         "result": {
             "operation": "contact_profile_pic",
             **(result if isinstance(result, dict) else {"url": result}),
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         },
         "execution_time": time.time() - start_time,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
 
 
 async def _handle_list_channels(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
     """Handle list_channels operation - list subscribed newsletter channels."""
-    refresh = parameters.get('refresh', False)
-    limit = parameters.get('limit', 20)
+    refresh = parameters.get("refresh", False)
+    limit = parameters.get("limit", 20)
 
     rpc_params: Dict[str, Any] = {}
     if refresh:
-        rpc_params['refresh'] = True
+        rpc_params["refresh"] = True
 
-    data = await rpc_call('newsletters', rpc_params)
+    data = await rpc_call("newsletters", rpc_params)
 
-    if isinstance(data, dict) and not data.get('success', True):
-        raise Exception(data.get('error', 'Failed to list channels'))
+    if isinstance(data, dict) and not data.get("success", True):
+        raise Exception(data.get("error", "Failed to list channels"))
 
-    channels = data if isinstance(data, list) else data.get('result', [])
+    channels = data if isinstance(data, list) else data.get("result", [])
     total_found = len(channels)
 
     # Return essential fields only
     channels_limited = [
-        {"jid": c.get("jid", ""), "name": c.get("name", ""), "subscriber_count": c.get("subscriber_count", 0)}
-        for c in channels[:limit]
+        {"jid": c.get("jid", ""), "name": c.get("name", ""), "subscriber_count": c.get("subscriber_count", 0)} for c in channels[:limit]
     ]
 
     return {
@@ -667,41 +631,37 @@ async def _handle_list_channels(node_id: str, parameters: Dict[str, Any], start_
             "returned": len(channels_limited),
             "has_more": total_found > limit,
             "hint": f"Showing {len(channels_limited)} of {total_found} channels." if total_found > limit else None,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         },
         "execution_time": time.time() - start_time,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
 
 
 async def _handle_get_channel_info(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
     """Handle get_channel_info operation - get channel details."""
-    channel_jid = parameters.get('channel_jid')
+    channel_jid = parameters.get("channel_jid")
     if not channel_jid:
         raise ValueError("Channel JID is required")
 
     rpc_params: Dict[str, Any] = _resolve_channel_identifier(channel_jid)
-    if parameters.get('refresh'):
-        rpc_params['refresh'] = True
+    if parameters.get("refresh"):
+        rpc_params["refresh"] = True
 
-    data = await rpc_call('newsletter_info', rpc_params)
+    data = await rpc_call("newsletter_info", rpc_params)
 
-    if isinstance(data, dict) and not data.get('success', True):
-        raise Exception(data.get('error', 'Failed to get channel info'))
+    if isinstance(data, dict) and not data.get("success", True):
+        raise Exception(data.get("error", "Failed to get channel info"))
 
-    result = data if not isinstance(data, dict) or 'result' not in data else data.get('result', data)
+    result = data if not isinstance(data, dict) or "result" not in data else data.get("result", data)
 
     return {
         "success": True,
         "node_id": node_id,
         "node_type": "whatsappDb",
-        "result": {
-            "operation": "get_channel_info",
-            **result,
-            "timestamp": datetime.now().isoformat()
-        },
+        "result": {"operation": "get_channel_info", **result, "timestamp": datetime.now().isoformat()},
         "execution_time": time.time() - start_time,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
 
 
@@ -711,53 +671,53 @@ async def _handle_channel_messages(node_id: str, parameters: Dict[str, Any], sta
     Schema params (newsletter_messages RPC):
       jid (required), count, offset, before, since, until, media_type, search, refresh
     """
-    channel_jid = parameters.get('channel_jid')
+    channel_jid = parameters.get("channel_jid")
     jid = await _resolve_to_jid(channel_jid, rpc_call)
 
-    count = parameters.get('channel_count', 20)
-    rpc_params: Dict[str, Any] = {'jid': jid, 'count': count}
+    count = parameters.get("channel_count", 20)
+    rpc_params: Dict[str, Any] = {"jid": jid, "count": count}
 
-    before_server_id = parameters.get('before_server_id')
+    before_server_id = parameters.get("before_server_id")
     if before_server_id:
-        rpc_params['before'] = int(before_server_id)
+        rpc_params["before"] = int(before_server_id)
 
     # Pagination offset
-    msg_offset = parameters.get('message_offset')
+    msg_offset = parameters.get("message_offset")
     if msg_offset:
-        rpc_params['offset'] = int(msg_offset)
+        rpc_params["offset"] = int(msg_offset)
 
     # Date range filters (unix timestamps as strings)
-    since = parameters.get('since')
+    since = parameters.get("since")
     if since:
-        rpc_params['since'] = str(since)
+        rpc_params["since"] = str(since)
 
-    until = parameters.get('until')
+    until = parameters.get("until")
     if until:
-        rpc_params['until'] = str(until)
+        rpc_params["until"] = str(until)
 
     # Media type filter
-    media_type = parameters.get('media_type')
-    if media_type and media_type != 'all':
-        rpc_params['media_type'] = media_type
+    media_type = parameters.get("media_type")
+    if media_type and media_type != "all":
+        rpc_params["media_type"] = media_type
 
     # Text search
-    search = parameters.get('search')
+    search = parameters.get("search")
     if search:
-        rpc_params['search'] = search
+        rpc_params["search"] = search
 
     # Force refresh bypassing cache
-    if parameters.get('refresh'):
-        rpc_params['refresh'] = True
+    if parameters.get("refresh"):
+        rpc_params["refresh"] = True
 
-    data = await rpc_call('newsletter_messages', rpc_params)
+    data = await rpc_call("newsletter_messages", rpc_params)
 
-    if isinstance(data, dict) and not data.get('success', True):
-        raise Exception(data.get('error', 'Failed to get channel messages'))
+    if isinstance(data, dict) and not data.get("success", True):
+        raise Exception(data.get("error", "Failed to get channel messages"))
 
-    messages = data if isinstance(data, list) else data.get('result', [])
+    messages = data if isinstance(data, list) else data.get("result", [])
 
     # Enrich with media data if requested
-    if parameters.get('include_media_data') and messages:
+    if parameters.get("include_media_data") and messages:
         await _enrich_messages_with_media(messages, rpc_call)
 
     return {
@@ -769,53 +729,48 @@ async def _handle_channel_messages(node_id: str, parameters: Dict[str, Any], sta
             "messages": messages,
             "count": len(messages),
             "channel_jid": channel_jid,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         },
         "execution_time": time.time() - start_time,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
 
 
 async def _handle_channel_stats(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
     """Handle channel_stats operation - get channel subscriber/view stats."""
-    channel_jid = parameters.get('channel_jid')
+    channel_jid = parameters.get("channel_jid")
     if not channel_jid:
         raise ValueError("Channel JID is required")
 
-    count = parameters.get('channel_count', 10)
-    rpc_params: Dict[str, Any] = {**_resolve_channel_identifier(channel_jid), 'count': count}
+    count = parameters.get("channel_count", 10)
+    rpc_params: Dict[str, Any] = {**_resolve_channel_identifier(channel_jid), "count": count}
 
-    data = await rpc_call('newsletter_stats', rpc_params)
+    data = await rpc_call("newsletter_stats", rpc_params)
 
-    if isinstance(data, dict) and not data.get('success', True):
-        raise Exception(data.get('error', 'Failed to get channel stats'))
+    if isinstance(data, dict) and not data.get("success", True):
+        raise Exception(data.get("error", "Failed to get channel stats"))
 
-    result = data if not isinstance(data, dict) or 'result' not in data else data.get('result', data)
+    result = data if not isinstance(data, dict) or "result" not in data else data.get("result", data)
 
     return {
         "success": True,
         "node_id": node_id,
         "node_type": "whatsappDb",
-        "result": {
-            "operation": "channel_stats",
-            **result,
-            "channel_jid": channel_jid,
-            "timestamp": datetime.now().isoformat()
-        },
+        "result": {"operation": "channel_stats", **result, "channel_jid": channel_jid, "timestamp": datetime.now().isoformat()},
         "execution_time": time.time() - start_time,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
 
 
 async def _handle_channel_follow(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
     """Handle channel_follow operation - follow/subscribe to a channel."""
-    channel_jid = parameters.get('channel_jid')
+    channel_jid = parameters.get("channel_jid")
     jid = await _resolve_to_jid(channel_jid, rpc_call)
 
-    data = await rpc_call('newsletter_follow', {'jid': jid})
+    data = await rpc_call("newsletter_follow", {"jid": jid})
 
-    if isinstance(data, dict) and not data.get('success', True):
-        raise Exception(data.get('error', 'Failed to follow channel'))
+    if isinstance(data, dict) and not data.get("success", True):
+        raise Exception(data.get("error", "Failed to follow channel"))
 
     return {
         "success": True,
@@ -825,22 +780,22 @@ async def _handle_channel_follow(node_id: str, parameters: Dict[str, Any], start
             "operation": "channel_follow",
             "channel_jid": channel_jid,
             "status": "followed",
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         },
         "execution_time": time.time() - start_time,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
 
 
 async def _handle_channel_unfollow(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
     """Handle channel_unfollow operation - unfollow/unsubscribe from a channel."""
-    channel_jid = parameters.get('channel_jid')
+    channel_jid = parameters.get("channel_jid")
     jid = await _resolve_to_jid(channel_jid, rpc_call)
 
-    data = await rpc_call('newsletter_unfollow', {'jid': jid})
+    data = await rpc_call("newsletter_unfollow", {"jid": jid})
 
-    if isinstance(data, dict) and not data.get('success', True):
-        raise Exception(data.get('error', 'Failed to unfollow channel'))
+    if isinstance(data, dict) and not data.get("success", True):
+        raise Exception(data.get("error", "Failed to unfollow channel"))
 
     return {
         "success": True,
@@ -850,60 +805,56 @@ async def _handle_channel_unfollow(node_id: str, parameters: Dict[str, Any], sta
             "operation": "channel_unfollow",
             "channel_jid": channel_jid,
             "status": "unfollowed",
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         },
         "execution_time": time.time() - start_time,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
 
 
 async def _handle_channel_create(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
     """Handle channel_create operation - create a new newsletter channel."""
-    channel_name = parameters.get('channel_name')
+    channel_name = parameters.get("channel_name")
     if not channel_name:
         raise ValueError("Channel name is required")
 
-    rpc_params: Dict[str, Any] = {'name': channel_name}
-    description = parameters.get('channel_description')
+    rpc_params: Dict[str, Any] = {"name": channel_name}
+    description = parameters.get("channel_description")
     if description:
-        rpc_params['description'] = description
-    picture = parameters.get('picture')
+        rpc_params["description"] = description
+    picture = parameters.get("picture")
     if picture:
-        rpc_params['picture'] = picture
+        rpc_params["picture"] = picture
 
-    data = await rpc_call('newsletter_create', rpc_params)
+    data = await rpc_call("newsletter_create", rpc_params)
 
-    if isinstance(data, dict) and not data.get('success', True):
-        raise Exception(data.get('error', 'Failed to create channel'))
+    if isinstance(data, dict) and not data.get("success", True):
+        raise Exception(data.get("error", "Failed to create channel"))
 
-    result = data if not isinstance(data, dict) or 'result' not in data else data.get('result', data)
+    result = data if not isinstance(data, dict) or "result" not in data else data.get("result", data)
 
     return {
         "success": True,
         "node_id": node_id,
         "node_type": "whatsappDb",
-        "result": {
-            "operation": "channel_create",
-            **result,
-            "timestamp": datetime.now().isoformat()
-        },
+        "result": {"operation": "channel_create", **result, "timestamp": datetime.now().isoformat()},
         "execution_time": time.time() - start_time,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
 
 
 async def _handle_channel_mute(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
     """Handle channel_mute operation - mute/unmute a newsletter channel."""
-    channel_jid = parameters.get('channel_jid')
+    channel_jid = parameters.get("channel_jid")
     jid = await _resolve_to_jid(channel_jid, rpc_call)
 
-    mute = parameters.get('mute', True)
-    rpc_params = {'jid': jid, 'mute': bool(mute)}
+    mute = parameters.get("mute", True)
+    rpc_params = {"jid": jid, "mute": bool(mute)}
 
-    data = await rpc_call('newsletter_mute', rpc_params)
+    data = await rpc_call("newsletter_mute", rpc_params)
 
-    if isinstance(data, dict) and not data.get('success', True):
-        raise Exception(data.get('error', 'Failed to mute/unmute channel'))
+    if isinstance(data, dict) and not data.get("success", True):
+        raise Exception(data.get("error", "Failed to mute/unmute channel"))
 
     return {
         "success": True,
@@ -914,32 +865,32 @@ async def _handle_channel_mute(node_id: str, parameters: Dict[str, Any], start_t
             "channel_jid": channel_jid,
             "muted": mute,
             "status": "muted" if mute else "unmuted",
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         },
         "execution_time": time.time() - start_time,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
 
 
 async def _handle_channel_mark_viewed(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
     """Handle channel_mark_viewed operation - mark channel messages as viewed."""
-    channel_jid = parameters.get('channel_jid')
+    channel_jid = parameters.get("channel_jid")
     jid = await _resolve_to_jid(channel_jid, rpc_call)
 
-    server_ids_raw = parameters.get('server_ids', '')
+    server_ids_raw = parameters.get("server_ids", "")
     if not server_ids_raw:
         raise ValueError("server_ids is required (comma-separated message IDs)")
 
-    server_ids = [int(sid.strip()) for sid in str(server_ids_raw).split(',') if sid.strip()]
+    server_ids = [int(sid.strip()) for sid in str(server_ids_raw).split(",") if sid.strip()]
     if not server_ids:
         raise ValueError("At least one server_id is required")
 
-    rpc_params = {'jid': jid, 'server_ids': server_ids}
+    rpc_params = {"jid": jid, "server_ids": server_ids}
 
-    data = await rpc_call('newsletter_mark_viewed', rpc_params)
+    data = await rpc_call("newsletter_mark_viewed", rpc_params)
 
-    if isinstance(data, dict) and not data.get('success', True):
-        raise Exception(data.get('error', 'Failed to mark channel as viewed'))
+    if isinstance(data, dict) and not data.get("success", True):
+        raise Exception(data.get("error", "Failed to mark channel as viewed"))
 
     return {
         "success": True,
@@ -948,36 +899,32 @@ async def _handle_channel_mark_viewed(node_id: str, parameters: Dict[str, Any],
         "result": {
             "operation": "channel_mark_viewed",
             "channel_jid": channel_jid,
-            "server_ids": ','.join(str(s) for s in server_ids),
+            "server_ids": ",".join(str(s) for s in server_ids),
             "status": "marked_viewed",
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         },
         "execution_time": time.time() - start_time,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
 
 
 async def _handle_newsletter_react(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
     """Handle newsletter_react operation - react to a channel message."""
-    channel_jid = parameters.get('channel_jid')
+    channel_jid = parameters.get("channel_jid")
     jid = await _resolve_to_jid(channel_jid, rpc_call)
 
-    server_id = parameters.get('react_server_id')
+    server_id = parameters.get("react_server_id")
     if not server_id:
         raise ValueError("Message server ID is required")
 
-    reaction = parameters.get('reaction', '')
+    reaction = parameters.get("reaction", "")
 
-    rpc_params: Dict[str, Any] = {
-        'jid': jid,
-        'server_id': int(server_id),
-        'reaction': reaction
-    }
+    rpc_params: Dict[str, Any] = {"jid": jid, "server_id": int(server_id), "reaction": reaction}
 
-    data = await rpc_call('newsletter_react', rpc_params)
+    data = await rpc_call("newsletter_react", rpc_params)
 
-    if isinstance(data, dict) and not data.get('success', True):
-        raise Exception(data.get('error', 'Failed to react to channel message'))
+    if isinstance(data, dict) and not data.get("success", True):
+        raise Exception(data.get("error", "Failed to react to channel message"))
 
     return {
         "success": True,
@@ -988,34 +935,34 @@ async def _handle_newsletter_react(node_id: str, parameters: Dict[str, Any], sta
             "channel_jid": channel_jid,
             "server_id": int(server_id),
             "reaction": reaction,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         },
         "execution_time": time.time() - start_time,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
 
 
 async def _handle_newsletter_live_updates(node_id: str, parameters: Dict[str, Any], start_time: float, rpc_call) -> Dict[str, Any]:
     """Handle newsletter_live_updates operation - subscribe to live view/reaction counts."""
-    channel_jid = parameters.get('channel_jid')
+    channel_jid = parameters.get("channel_jid")
     jid = await _resolve_to_jid(channel_jid, rpc_call)
 
-    server_ids_raw = parameters.get('server_ids', '')
+    server_ids_raw = parameters.get("server_ids", "")
     if not server_ids_raw:
         raise ValueError("server_ids is required (comma-separated message IDs)")
 
-    server_ids = [int(sid.strip()) for sid in str(server_ids_raw).split(',') if sid.strip()]
+    server_ids = [int(sid.strip()) for sid in str(server_ids_raw).split(",") if sid.strip()]
     if not server_ids:
         raise ValueError("At least one server_id is required")
 
-    rpc_params = {'jid': jid, 'server_ids': server_ids}
+    rpc_params = {"jid": jid, "server_ids": server_ids}
 
-    data = await rpc_call('newsletter_live_updates', rpc_params)
+    data = await rpc_call("newsletter_live_updates", rpc_params)
 
-    if isinstance(data, dict) and not data.get('success', True):
-        raise Exception(data.get('error', 'Failed to subscribe to live updates'))
+    if isinstance(data, dict) and not data.get("success", True):
+        raise Exception(data.get("error", "Failed to subscribe to live updates"))
 
-    result = data if not isinstance(data, dict) or 'result' not in data else data.get('result', data)
+    result = data if not isinstance(data, dict) or "result" not in data else data.get("result", data)
 
     return {
         "success": True,
@@ -1025,10 +972,8 @@ async def _handle_newsletter_live_updates(node_id: str, parameters: Dict[str, An
             "operation": "newsletter_live_updates",
             "channel_jid": channel_jid,
             **(result if isinstance(result, dict) else {}),
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         },
         "execution_time": time.time() - start_time,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
-
-