universal-mcp-applications 0.1.32__py3-none-any.whl → 0.1.36rc2__py3-none-any.whl

universal_mcp/applications/whatsapp/app.py

@@ -1,49 +1,21 @@
 from typing import Any
-
 import requests
 from universal_mcp.agentr.integration import AgentrIntegration
 from universal_mcp.applications.application import BaseApplication
 from universal_mcp.exceptions import NotAuthorizedError
-
-from universal_mcp.applications.whatsapp.whatsapp import (
-    WHATSAPP_API_BASE_URL,
-)
-from universal_mcp.applications.whatsapp.whatsapp import (
-    download_media as whatsapp_download_media,
-)
-from universal_mcp.applications.whatsapp.whatsapp import (
-    get_chat as whatsapp_get_chat,
-)
-from universal_mcp.applications.whatsapp.whatsapp import (
-    get_contact_chats as whatsapp_get_contact_chats,
-)
-from universal_mcp.applications.whatsapp.whatsapp import (
-    get_direct_chat_by_contact as whatsapp_get_direct_chat_by_contact,
-)
-from universal_mcp.applications.whatsapp.whatsapp import (
-    get_last_interaction as whatsapp_get_last_interaction,
-)
-from universal_mcp.applications.whatsapp.whatsapp import (
-    get_message_context as whatsapp_get_message_context,
-)
-from universal_mcp.applications.whatsapp.whatsapp import (
-    list_chats as whatsapp_list_chats,
-)
-from universal_mcp.applications.whatsapp.whatsapp import (
-    list_messages as whatsapp_list_messages,
-)
-from universal_mcp.applications.whatsapp.whatsapp import (
-    search_contacts as whatsapp_search_contacts,
-)
-from universal_mcp.applications.whatsapp.whatsapp import (
-    send_audio_message as whatsapp_audio_voice_message,
-)
-from universal_mcp.applications.whatsapp.whatsapp import (
-    send_file as whatsapp_send_file,
-)
-from universal_mcp.applications.whatsapp.whatsapp import (
-    send_message as whatsapp_send_message,
-)
+from universal_mcp.applications.whatsapp.whatsapp import WHATSAPP_API_BASE_URL
+from universal_mcp.applications.whatsapp.whatsapp import download_media as whatsapp_download_media
+from universal_mcp.applications.whatsapp.whatsapp import get_chat as whatsapp_get_chat
+from universal_mcp.applications.whatsapp.whatsapp import get_contact_chats as whatsapp_get_contact_chats
+from universal_mcp.applications.whatsapp.whatsapp import get_direct_chat_by_contact as whatsapp_get_direct_chat_by_contact
+from universal_mcp.applications.whatsapp.whatsapp import get_last_interaction as whatsapp_get_last_interaction
+from universal_mcp.applications.whatsapp.whatsapp import get_message_context as whatsapp_get_message_context
+from universal_mcp.applications.whatsapp.whatsapp import list_chats as whatsapp_list_chats
+from universal_mcp.applications.whatsapp.whatsapp import list_messages as whatsapp_list_messages
+from universal_mcp.applications.whatsapp.whatsapp import search_contacts as whatsapp_search_contacts
+from universal_mcp.applications.whatsapp.whatsapp import send_audio_message as whatsapp_audio_voice_message
+from universal_mcp.applications.whatsapp.whatsapp import send_file as whatsapp_send_file
+from universal_mcp.applications.whatsapp.whatsapp import send_message as whatsapp_send_message
 
 
 class WhatsappApp(BaseApplication):
@@ -63,7 +35,6 @@ class WhatsappApp(BaseApplication):
         """
         if not self.integration:
             raise ValueError("No integration available to get API key from")
-
         try:
             headers = self.integration.client.client.headers
             api_key = headers.get("X-API-KEY")
@@ -89,19 +60,13 @@ class WhatsappApp(BaseApplication):
         Triggers WhatsApp authentication flow when no integration is available.
         Raises NotAuthorizedError with authorization URL when authentication is needed.
         """
-
-        # Try WhatsApp authentication
         auth_result = self._authenticate_whatsapp()
         if auth_result[0] is True:
             return True
         elif isinstance(auth_result[1], str):
-            # auth_result contains the authorization URL message
             raise NotAuthorizedError(auth_result[1])
         else:
-            # WhatsApp authentication failed but no URL provided
-            raise NotAuthorizedError(
-                "WhatsApp authentication failed. Please check your configuration."
-            )
+            raise NotAuthorizedError("WhatsApp authentication failed. Please check your configuration.")
 
     def _authenticate_whatsapp(self) -> tuple[bool, str]:
         """
@@ -109,20 +74,11 @@ class WhatsappApp(BaseApplication):
         Makes a POST request to the auth endpoint.
         """
         try:
-            # Use the API key from the integration
             user_id = self.api_key
             if not user_id:
                 raise ValueError("No API key available from integration")
-
             auth_url = f"{self.base_url}/api/auth"
-
-            response = requests.post(
-                auth_url,
-                headers={"Content-Type": "application/json"},
-                json={"user_id": user_id},
-                timeout=60,
-            )
-
+            response = requests.post(auth_url, headers={"Content-Type": "application/json"}, json={"user_id": user_id}, timeout=60)
             if response.status_code == 200:
                 result = response.json()
                 if result.get("status") == "qr_required":
@@ -134,15 +90,12 @@ class WhatsappApp(BaseApplication):
                 elif result.get("status") == "connected":
                     return (True, "User already authenticated")
             else:
-                # Return QR URL even when auth fails, so user can try to authenticate
                 qr_url = f"{self.base_url}/api/qr?user_id={user_id}"
                 return (
                     False,
                     f"Please ask the user to visit the following url to authorize WhatsApp: {qr_url}. Render the url in proper markdown format with a clickable link.",
                 )
-
         except Exception:
-            # Return QR URL when there's an exception, so user can try to authenticate
             user_id = self.api_key
             if user_id:
                 qr_url = f"{self.base_url}/api/qr?user_id={user_id}"
@@ -153,10 +106,7 @@ class WhatsappApp(BaseApplication):
             else:
                 return (False, "No API key available from integration")
 
-    def search_contacts(
-        self,
-        query: str,
-    ) -> list[dict[str, Any]]:
+    async def search_contacts(self, query: str) -> list[dict[str, Any]]:
         """
         Searches for WhatsApp contacts by name or phone number. This function takes a query string, handles user authentication, and calls the underlying API to find and return a list of matching contacts. It serves as the primary method to look up contact information within the application.
 
@@ -174,15 +124,12 @@ class WhatsappApp(BaseApplication):
         """
         if query is None:
             raise ValueError("Missing required parameter 'query'.")
-
-        # Trigger authentication
         self._authenticator()
-
         user_id = self.api_key
         contacts = whatsapp_search_contacts(query, user_id)
         return contacts
 
-    def search_messages(
+    async def search_messages(
         self,
         after: str | None = None,
         before: str | None = None,
@@ -219,9 +166,7 @@ class WhatsappApp(BaseApplication):
         Tags:
             whatsapp.messages, important
         """
-        # Trigger authentication
         self._authenticator()
-
         user_id = self.api_key
         messages = whatsapp_list_messages(
             after=after,
@@ -238,13 +183,8 @@ class WhatsappApp(BaseApplication):
         )
         return messages
 
-    def search_chats(
-        self,
-        query: str | None = None,
-        limit: int = 20,
-        page: int = 0,
-        include_last_message: bool = True,
-        sort_by: str = "last_active",
+    async def search_chats(
+        self, query: str | None = None, limit: int = 20, page: int = 0, include_last_message: bool = True, sort_by: str = "last_active"
     ) -> list[dict[str, Any]]:
         """
         Retrieves a paginated list of WhatsApp chats, allowing filtering by a search query and sorting by activity or name. Unlike `get_chat`, which fetches a single known chat, this function provides broad search and discovery capabilities across multiple user conversations.
@@ -265,25 +205,14 @@ class WhatsappApp(BaseApplication):
         Tags:
             whatsapp.chats, important
         """
-        # Trigger authentication
         self._authenticator()
-
         user_id = self.api_key
         chats = whatsapp_list_chats(
-            query=query,
-            limit=limit,
-            page=page,
-            include_last_message=include_last_message,
-            sort_by=sort_by,
-            user_id=user_id,
+            query=query, limit=limit, page=page, include_last_message=include_last_message, sort_by=sort_by, user_id=user_id
         )
         return chats
 
-    def get_chat_by_jid(
-        self,
-        chat_jid: str,
-        include_last_message: bool = True,
-    ) -> dict[str, Any]:
+    async def get_chat_by_jid(self, chat_jid: str, include_last_message: bool = True) -> dict[str, Any]:
         """
         Retrieves metadata for a specific WhatsApp chat (direct or group) using its unique JID. It can optionally include the most recent message. This precise JID-based lookup distinguishes it from `get_direct_chat_by_contact`, which uses a phone number, and `list_chats`, which performs a broader search.
 
@@ -302,18 +231,12 @@ class WhatsappApp(BaseApplication):
         """
         if chat_jid is None:
             raise ValueError("Missing required parameter 'chat_jid'.")
-
-        # Trigger authentication
         self._authenticator()
-
         user_id = self.api_key
         chat = whatsapp_get_chat(chat_jid, include_last_message, user_id)
         return chat
 
-    def get_direct_chat_by_phone_number(
-        self,
-        sender_phone_number: str,
-    ) -> dict[str, Any]:
+    async def get_direct_chat_by_phone_number(self, sender_phone_number: str) -> dict[str, Any]:
         """
         Retrieves metadata for a direct (one-on-one) WhatsApp chat using a contact's phone number. Unlike `get_chat` which requires a JID, this provides a simpler way to find direct conversations. Returns a dictionary containing the chat's details, such as its JID and name.
 
@@ -331,20 +254,12 @@ class WhatsappApp(BaseApplication):
         """
         if sender_phone_number is None:
             raise ValueError("Missing required parameter 'sender_phone_number'.")
-
-        # Trigger authentication
         self._authenticator()
-
         user_id = self.api_key
         chat = whatsapp_get_direct_chat_by_contact(sender_phone_number, user_id)
         return chat
 
-    def list_chats_by_contact_jid(
-        self,
-        jid: str,
-        limit: int = 20,
-        page: int = 0,
-    ) -> list[dict[str, Any]]:
+    async def list_chats_by_contact_jid(self, jid: str, limit: int = 20, page: int = 0) -> list[dict[str, Any]]:
         """
         Retrieves a paginated list of all WhatsApp chats, including direct messages and groups, that a specific contact participates in. The contact is identified by their unique JID. This differs from `get_direct_chat_by_contact` which only finds one-on-one chats.
 
@@ -364,18 +279,12 @@ class WhatsappApp(BaseApplication):
         """
         if jid is None:
             raise ValueError("Missing required parameter 'jid'.")
-
-        # Trigger authentication
         self._authenticator()
-
         user_id = self.api_key
         chats = whatsapp_get_contact_chats(jid, limit, page, user_id)
         return chats
 
-    def get_last_message_by_jid(
-        self,
-        jid: str,
-    ) -> str:
+    async def get_last_message_by_jid(self, jid: str) -> str:
         """
         Retrieves the content of the most recent message involving a specific contact, identified by their JID. It authenticates the user and returns the message directly as a string, offering a quick way to view the last communication without fetching full message objects or chat histories.
 
@@ -393,20 +302,12 @@ class WhatsappApp(BaseApplication):
         """
         if jid is None:
             raise ValueError("Missing required parameter 'jid'.")
-
-        # Trigger authentication
         self._authenticator()
-
         user_id = self.api_key
         message = whatsapp_get_last_interaction(jid, user_id)
         return message
 
-    def get_message_context(
-        self,
-        message_id: str,
-        before: int = 5,
-        after: int = 5,
-    ) -> dict[str, Any]:
+    async def get_message_context(self, message_id: str, before: int = 5, after: int = 5) -> dict[str, Any]:
         """
         Fetches the conversational context surrounding a specific WhatsApp message ID. It retrieves a configurable number of messages immediately preceding and following the target message. This provides a focused view of a dialogue, unlike `list_messages` which performs broader, filter-based searches.
 
@@ -426,19 +327,12 @@ class WhatsappApp(BaseApplication):
         """
         if message_id is None:
             raise ValueError("Missing required parameter 'message_id'.")
-
-        # Trigger authentication
         self._authenticator()
-
         user_id = self.api_key
         context = whatsapp_get_message_context(message_id, before, after, user_id)
         return context
 
-    def send_text_message(
-        self,
-        recipient: str,
-        message: str,
-    ) -> dict[str, Any]:
+    async def send_text_message(self, recipient: str, message: str) -> dict[str, Any]:
         """
         Authenticates the user and sends a text message to a specified WhatsApp recipient. The recipient can be an individual (via phone number) or a group (via JID). It returns a dictionary indicating the operation's success status and a corresponding message.
 
@@ -460,23 +354,12 @@ class WhatsappApp(BaseApplication):
             raise ValueError("Missing required parameter 'recipient'.")
         if message is None:
             raise ValueError("Missing required parameter 'message'.")
-
-        # Trigger authentication
         self._authenticator()
-
         user_id = self.api_key
-        # Call the whatsapp_send_message function with the unified recipient parameter
         success, status_message = whatsapp_send_message(recipient, message, user_id)
-        return {
-            "success": success,
-            "message": status_message,
-        }
+        return {"success": success, "message": status_message}
 
-    def send_attachment(
-        self,
-        recipient: str,
-        media_path: str,
-    ) -> dict[str, Any]:
+    async def send_attachment(self, recipient: str, media_path: str) -> dict[str, Any]:
         """
         Sends a media file (image, video, document, raw audio) as a standard attachment to a WhatsApp contact or group using their phone number or JID. Unlike `send_audio_message`, which creates a playable voice note, this function handles general file transfers. Returns a success status dictionary.
 
@@ -498,23 +381,12 @@ class WhatsappApp(BaseApplication):
             raise ValueError("Missing required parameter 'recipient'.")
         if media_path is None:
             raise ValueError("Missing required parameter 'media_path'.")
-
-        # Trigger authentication
         self._authenticator()
-
         user_id = self.api_key
-        # Call the whatsapp_send_file function
         success, status_message = whatsapp_send_file(recipient, media_path, user_id)
-        return {
-            "success": success,
-            "message": status_message,
-        }
+        return {"success": success, "message": status_message}
 
-    def send_voice_message(
-        self,
-        recipient: str,
-        media_path: str,
-    ) -> dict[str, Any]:
+    async def send_voice_message(self, recipient: str, media_path: str) -> dict[str, Any]:
         """
         Sends a local audio file as a playable WhatsApp voice message, converting it to the required format. Unlike `send_file` which sends audio as a document attachment, this function formats the audio as a voice note. It can be sent to an individual contact or a group chat.
 
@@ -536,24 +408,12 @@ class WhatsappApp(BaseApplication):
             raise ValueError("Missing required parameter 'recipient'.")
         if media_path is None:
             raise ValueError("Missing required parameter 'media_path'.")
-
-        # Trigger authentication
         self._authenticator()
-
         user_id = self.api_key
-        success, status_message = whatsapp_audio_voice_message(
-            recipient, media_path, user_id
-        )
-        return {
-            "success": success,
-            "message": status_message,
-        }
+        success, status_message = whatsapp_audio_voice_message(recipient, media_path, user_id)
+        return {"success": success, "message": status_message}
 
-    def download_media_from_message(
-        self,
-        message_id: str,
-        chat_jid: str,
-    ) -> dict[str, Any]:
+    async def download_media_from_message(self, message_id: str, chat_jid: str) -> dict[str, Any]:
         """
         Downloads media from a specific WhatsApp message, identified by its ID and chat JID. It saves the content to a local file and returns the file's path upon success. The function automatically handles user authentication before initiating the download.
 
@@ -574,24 +434,13 @@ class WhatsappApp(BaseApplication):
             raise ValueError("Missing required parameter 'message_id'.")
         if chat_jid is None:
             raise ValueError("Missing required parameter 'chat_jid'.")
-
-        # Trigger authentication
         self._authenticator()
-
         user_id = self.api_key
         file_path = whatsapp_download_media(message_id, chat_jid, user_id)
-
         if file_path:
-            return {
-                "success": True,
-                "message": "Media downloaded successfully",
-                "file_path": file_path,
-            }
+            return {"success": True, "message": "Media downloaded successfully", "file_path": file_path}
         else:
-            return {
-                "success": False,
-                "message": "Failed to download media",
-            }
+            return {"success": False, "message": "Failed to download media"}
 
     def list_tools(self):
         """

universal_mcp/applications/whatsapp/audio.py

@@ -58,14 +58,10 @@ def convert_to_opus_ogg(input_file, output_file=None, bitrate="32k", sample_rate
 
     try:
         # Run the ffmpeg command and capture output
-        subprocess.run(
-            cmd, capture_output=True, text=True, check=True
-        )
+        subprocess.run(cmd, capture_output=True, text=True, check=True)
         return output_file
     except subprocess.CalledProcessError as e:
-        raise RuntimeError(
-            f"Failed to convert audio. You likely need to install ffmpeg {e.stderr}"
-        )
+        raise RuntimeError(f"Failed to convert audio. You likely need to install ffmpeg {e.stderr}")
 
 
 def convert_to_opus_ogg_temp(input_file, bitrate="32k", sample_rate=24000):

universal_mcp/applications/whatsapp/whatsapp.py

@@ -54,9 +54,7 @@ class MessageContext:
     after: list[Message]
 
 
-def _make_api_request(
-    endpoint: str, method: str = "GET", data: dict = None, user_id: str = "default_user"
-) -> dict:
+def _make_api_request(endpoint: str, method: str = "GET", data: dict = None, user_id: str = "default_user") -> dict:
     """Make HTTP request to WhatsApp Bridge API."""
     url = f"{WHATSAPP_API_BASE_URL}/api/{endpoint}"
 
@@ -87,9 +85,7 @@ def _make_api_request(
 
 def get_sender_name(sender_jid: str, user_id: str = "default_user") -> str:
     """Get sender name via API call."""
-    result = _make_api_request(
-        "sender_name", data={"sender_jid": sender_jid}, user_id=user_id
-    )
+    result = _make_api_request("sender_name", data={"sender_jid": sender_jid}, user_id=user_id)
 
     if "error" in result:
         return sender_jid
@@ -97,9 +93,7 @@ def get_sender_name(sender_jid: str, user_id: str = "default_user") -> str:
     return result.get("name", sender_jid)
 
 
-def format_message(
-    message: Message, show_chat_info: bool = True, user_id: str = "default_user"
-) -> str:
+def format_message(message: Message, show_chat_info: bool = True, user_id: str = "default_user") -> str:
     """Print a single message with consistent formatting."""
     output = ""
 
@@ -113,18 +107,14 @@ def format_message(
         content_prefix = f"[{message.media_type} - Message ID: {message.id} - Chat JID: {message.chat_jid}] "
 
     try:
-        sender_name = (
-            get_sender_name(message.sender, user_id) if not message.is_from_me else "Me"
-        )
+        sender_name = get_sender_name(message.sender, user_id) if not message.is_from_me else "Me"
         output += f"From: {sender_name}: {content_prefix}{message.content}\n"
     except Exception:
         pass
     return output
 
 
-def format_messages_list(
-    messages: list[Message], show_chat_info: bool = True, user_id: str = "default_user"
-) -> str:
+def format_messages_list(messages: list[Message], show_chat_info: bool = True, user_id: str = "default_user") -> str:
     output = ""
     if not messages:
         output += "No messages to display."
@@ -173,9 +163,7 @@ def list_messages(
     return result.get("messages", "No messages found")
 
 
-def get_message_context(
-    message_id: str, before: int = 5, after: int = 5, user_id: str = "default_user"
-) -> MessageContext:
+def get_message_context(message_id: str, before: int = 5, after: int = 5, user_id: str = "default_user") -> MessageContext:
     """Get context around a specific message via API."""
     params = {"message_id": message_id, "before": before, "after": after}
 
@@ -222,9 +210,7 @@ def list_chats(
         chat = Chat(
             jid=chat_data["jid"],
             name=chat_data.get("name"),
-            last_message_time=datetime.fromisoformat(chat_data["last_message_time"])
-            if chat_data.get("last_message_time")
-            else None,
+            last_message_time=datetime.fromisoformat(chat_data["last_message_time"]) if chat_data.get("last_message_time") else None,
             last_message=chat_data.get("last_message"),
             last_sender=chat_data.get("last_sender"),
             last_is_from_me=chat_data.get("last_is_from_me"),
@@ -255,9 +241,7 @@ def search_contacts(query: str, user_id: str = "default_user") -> list[Contact]:
     return contacts
 
 
-def get_contact_chats(
-    jid: str, limit: int = 20, page: int = 0, user_id: str = "default_user"
-) -> list[Chat]:
+def get_contact_chats(jid: str, limit: int = 20, page: int = 0, user_id: str = "default_user") -> list[Chat]:
     """Get all chats involving the contact via API."""
     params = {"jid": jid, "limit": limit, "page": page}
 
@@ -273,9 +257,7 @@ def get_contact_chats(
         chat = Chat(
             jid=chat_data["jid"],
             name=chat_data.get("name"),
-            last_message_time=datetime.fromisoformat(chat_data["last_message_time"])
-            if chat_data.get("last_message_time")
-            else None,
+            last_message_time=datetime.fromisoformat(chat_data["last_message_time"]) if chat_data.get("last_message_time") else None,
             last_message=chat_data.get("last_message"),
             last_sender=chat_data.get("last_sender"),
             last_is_from_me=chat_data.get("last_is_from_me"),
@@ -295,9 +277,7 @@ def get_last_interaction(jid: str, user_id: str = "default_user") -> str:
     return result.get("message", "No interaction found")
 
 
-def get_chat(
-    chat_jid: str, include_last_message: bool = True, user_id: str = "default_user"
-) -> Chat | None:
+def get_chat(chat_jid: str, include_last_message: bool = True, user_id: str = "default_user") -> Chat | None:
     """Get chat metadata by JID via API."""
     params = {"chat_jid": chat_jid, "include_last_message": include_last_message}
 
@@ -313,18 +293,14 @@ def get_chat(
     return Chat(
         jid=chat_data["jid"],
         name=chat_data.get("name"),
-        last_message_time=datetime.fromisoformat(chat_data["last_message_time"])
-        if chat_data.get("last_message_time")
-        else None,
+        last_message_time=datetime.fromisoformat(chat_data["last_message_time"]) if chat_data.get("last_message_time") else None,
         last_message=chat_data.get("last_message"),
         last_sender=chat_data.get("last_sender"),
         last_is_from_me=chat_data.get("last_is_from_me"),
     )
 
 
-def get_direct_chat_by_contact(
-    sender_phone_number: str, user_id: str = "default_user"
-) -> Chat | None:
+def get_direct_chat_by_contact(sender_phone_number: str, user_id: str = "default_user") -> Chat | None:
     """Get chat metadata by sender phone number via API."""
     result = _make_api_request(
         "direct_chat",
@@ -342,18 +318,14 @@ def get_direct_chat_by_contact(
     return Chat(
         jid=chat_data["jid"],
         name=chat_data.get("name"),
-        last_message_time=datetime.fromisoformat(chat_data["last_message_time"])
-        if chat_data.get("last_message_time")
-        else None,
+        last_message_time=datetime.fromisoformat(chat_data["last_message_time"]) if chat_data.get("last_message_time") else None,
         last_message=chat_data.get("last_message"),
         last_sender=chat_data.get("last_sender"),
         last_is_from_me=chat_data.get("last_is_from_me"),
     )
 
 
-def send_message(
-    recipient: str, message: str, user_id: str = "default_user"
-) -> tuple[bool, str]:
+def send_message(recipient: str, message: str, user_id: str = "default_user") -> tuple[bool, str]:
     """Send message via API."""
     payload = {"user_id": user_id, "recipient": recipient, "message": message}
 
@@ -365,9 +337,7 @@ def send_message(
     return result.get("success", False), result.get("message", "Unknown response")
 
 
-def send_file(
-    recipient: str, media_path: str, user_id: str = "default_user"
-) -> tuple[bool, str]:
+def send_file(recipient: str, media_path: str, user_id: str = "default_user") -> tuple[bool, str]:
     """Send file via API."""
     payload = {"user_id": user_id, "recipient": recipient, "media_path": media_path}
 
@@ -379,9 +349,7 @@ def send_file(
     return result.get("success", False), result.get("message", "Unknown response")
 
 
-def send_audio_message(
-    recipient: str, media_path: str, user_id: str = "default_user"
-) -> tuple[bool, str]:
+def send_audio_message(recipient: str, media_path: str, user_id: str = "default_user") -> tuple[bool, str]:
     """Send audio message via API."""
     if not media_path.endswith(".ogg"):
         try:
@@ -402,9 +370,7 @@ def send_audio_message(
     return result.get("success", False), result.get("message", "Unknown response")
 
 
-def download_media(
-    message_id: str, chat_jid: str, user_id: str = "default_user"
-) -> str | None:
+def download_media(message_id: str, chat_jid: str, user_id: str = "default_user") -> str | None:
     """Download media from a message via API."""
     payload = {"user_id": user_id, "message_id": message_id, "chat_jid": chat_jid}