universal-mcp-applications 0.1.17__py3-none-any.whl → 0.1.33__py3-none-any.whl

universal_mcp/applications/whatsapp/whatsapp.py

@@ -1,15 +1,17 @@
-import requests
 import json
-from datetime import datetime
-from dataclasses import dataclass
-from typing import Optional, List, Tuple
 import os.path
-from . import audio
+from dataclasses import dataclass
+from datetime import datetime
+
+import requests
 from dotenv import load_dotenv
 
+from . import audio
+
 load_dotenv()
 
-WHATSAPP_API_BASE_URL = os.getenv('WHATSAPP_API_BASE_URL', "http://134.209.144.43:8080")
+WHATSAPP_API_BASE_URL = os.getenv("WHATSAPP_API_BASE_URL", "http://134.209.144.43:8080")
+
 
 @dataclass
 class Message:
@@ -19,45 +21,51 @@ class Message:
     is_from_me: bool
     chat_jid: str
     id: str
-    chat_name: Optional[str] = None
-    media_type: Optional[str] = None
+    chat_name: str | None = None
+    media_type: str | None = None
+
 
 @dataclass
 class Chat:
     jid: str
-    name: Optional[str]
-    last_message_time: Optional[datetime]
-    last_message: Optional[str] = None
-    last_sender: Optional[str] = None
-    last_is_from_me: Optional[bool] = None
+    name: str | None
+    last_message_time: datetime | None
+    last_message: str | None = None
+    last_sender: str | None = None
+    last_is_from_me: bool | None = None
 
     @property
     def is_group(self) -> bool:
         """Determine if chat is a group based on JID pattern."""
         return self.jid.endswith("@g.us")
 
+
 @dataclass
 class Contact:
     phone_number: str
-    name: Optional[str]
+    name: str | None
     jid: str
 
+
 @dataclass
 class MessageContext:
     message: Message
-    before: List[Message]
-    after: List[Message]
+    before: list[Message]
+    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}"
-    
+
     # Add user_id to query parameters for GET requests
     if method.upper() == "GET" and data:
         data["user_id"] = user_id
     elif method.upper() == "GET":
         data = {"user_id": user_id}
-    
+
     try:
         if method.upper() == "GET":
             response = requests.get(url, params=data, timeout=30)
@@ -65,68 +73,80 @@ def _make_api_request(endpoint: str, method: str = "GET", data: dict = None, use
             response = requests.post(url, json=data, timeout=30)
         else:
             raise ValueError(f"Unsupported HTTP method: {method}")
-        
+
         if response.status_code == 200:
             return response.json()
         else:
             return {"error": f"HTTP {response.status_code}: {response.text}"}
-            
+
     except requests.RequestException as e:
         return {"error": f"Request failed: {str(e)}"}
     except json.JSONDecodeError:
         return {"error": f"Invalid JSON response: {response.text}"}
 
+
 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
-    
+
     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 = ""
-    
+
     if show_chat_info and message.chat_name:
         output += f"[{message.timestamp:%Y-%m-%d %H:%M:%S}] Chat: {message.chat_name} "
     else:
         output += f"[{message.timestamp:%Y-%m-%d %H:%M:%S}] "
-        
+
     content_prefix = ""
-    if hasattr(message, 'media_type') and message.media_type:
+    if hasattr(message, "media_type") and message.media_type:
         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 as e:
-        print(f"Error formatting message: {e}")
+    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."
         return output
-    
+
     for message in messages:
         output += format_message(message, show_chat_info, user_id)
     return output
 
+
 def list_messages(
-    after: Optional[str] = None,
-    before: Optional[str] = None,
-    sender_phone_number: Optional[str] = None,
-    chat_jid: Optional[str] = None,
-    query: Optional[str] = None,
+    after: str | None = None,
+    before: str | None = None,
+    sender_phone_number: str | None = None,
+    chat_jid: str | None = None,
+    query: str | None = None,
     limit: int = 20,
     page: int = 0,
     include_context: bool = True,
     context_before: int = 1,
     context_after: int = 1,
-    user_id: str = "default_user"
+    user_id: str = "default_user",
 ) -> str:
     """Get messages matching the specified criteria with optional context via API."""
     params = {
@@ -139,260 +159,262 @@ def list_messages(
         "page": page,
         "include_context": include_context,
         "context_before": context_before,
-        "context_after": context_after
+        "context_after": context_after,
     }
-    
+
     # Remove None values
     params = {k: v for k, v in params.items() if v is not None}
-    
+
     result = _make_api_request("messages", data=params, user_id=user_id)
-    
+
     if "error" in result:
         return f"Error retrieving messages: {result['error']}"
-    
+
     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"
+    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
-    }
-    
+    params = {"message_id": message_id, "before": before, "after": after}
+
     result = _make_api_request("message_context", data=params, user_id=user_id)
-    
+
     if "error" in result:
         raise ValueError(f"Error getting message context: {result['error']}")
-    
+
     # Parse the response into MessageContext object
     # This would need to be implemented based on the API response structure
     # For now, returning a simple error message
     raise NotImplementedError("Message context API not yet implemented in bridge")
 
+
 def list_chats(
-    query: Optional[str] = None,
+    query: str | None = None,
     limit: int = 20,
     page: int = 0,
     include_last_message: bool = True,
     sort_by: str = "last_active",
-    user_id: str = "default_user"
-) -> List[Chat]:
+    user_id: str = "default_user",
+) -> list[Chat]:
     """Get chats matching the specified criteria via API."""
     params = {
         "query": query,
         "limit": limit,
         "page": page,
         "include_last_message": include_last_message,
-        "sort_by": sort_by
+        "sort_by": sort_by,
     }
-    
+
     # Remove None values
     params = {k: v for k, v in params.items() if v is not None}
-    
+
     result = _make_api_request("chats", data=params, user_id=user_id)
-    
+
     if "error" in result:
-        print(f"Error retrieving chats: {result['error']}")
         return []
-    
+
     chats_data = result.get("chats", [])
     chats = []
-    
+
     for chat_data in chats_data:
         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")
+            last_is_from_me=chat_data.get("last_is_from_me"),
         )
         chats.append(chat)
-    
+
     return chats
 
-def search_contacts(query: str, user_id: str = "default_user") -> List[Contact]:
+
+def search_contacts(query: str, user_id: str = "default_user") -> list[Contact]:
     """Search contacts by name or phone number via API."""
     result = _make_api_request("contacts", data={"query": query}, user_id=user_id)
-    
+
     if "error" in result:
-        print(f"Error searching contacts: {result['error']}")
         return []
-    
+
     contacts_data = result.get("contacts", [])
     contacts = []
-    
+
     for contact_data in contacts_data:
         contact = Contact(
             phone_number=contact_data["phone_number"],
             name=contact_data.get("name"),
-            jid=contact_data["jid"]
+            jid=contact_data["jid"],
         )
         contacts.append(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
-    }
-    
+    params = {"jid": jid, "limit": limit, "page": page}
+
     result = _make_api_request("contact_chats", data=params, user_id=user_id)
-    
+
     if "error" in result:
-        print(f"Error getting contact chats: {result['error']}")
         return []
-    
+
     chats_data = result.get("chats", [])
     chats = []
-    
+
     for chat_data in chats_data:
         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")
+            last_is_from_me=chat_data.get("last_is_from_me"),
         )
         chats.append(chat)
-    
+
     return chats
 
+
 def get_last_interaction(jid: str, user_id: str = "default_user") -> str:
     """Get most recent message involving the contact via API."""
     result = _make_api_request("last_interaction", data={"jid": jid}, user_id=user_id)
-    
+
     if "error" in result:
         return f"Error getting last interaction: {result['error']}"
-    
+
     return result.get("message", "No interaction found")
 
-def get_chat(chat_jid: str, include_last_message: bool = True, user_id: str = "default_user") -> Optional[Chat]:
+
+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
-    }
-    
+    params = {"chat_jid": chat_jid, "include_last_message": include_last_message}
+
     result = _make_api_request("chat", data=params, user_id=user_id)
-    
+
     if "error" in result:
-        print(f"Error getting chat: {result['error']}")
         return None
-    
+
     chat_data = result.get("chat")
     if not chat_data:
         return None
-    
+
     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")
+        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") -> Optional[Chat]:
+
+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", data={"sender_phone_number": sender_phone_number}, user_id=user_id)
-    
+    result = _make_api_request(
+        "direct_chat",
+        data={"sender_phone_number": sender_phone_number},
+        user_id=user_id,
+    )
+
     if "error" in result:
-        print(f"Error getting direct chat: {result['error']}")
         return None
-    
+
     chat_data = result.get("chat")
     if not chat_data:
         return None
-    
+
     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")
+        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
-    }
-    
+    payload = {"user_id": user_id, "recipient": recipient, "message": message}
+
     result = _make_api_request("send", method="POST", data=payload, user_id=user_id)
-    
+
     if "error" in result:
         return False, result["error"]
-    
+
     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
-    }
-    
+    payload = {"user_id": user_id, "recipient": recipient, "media_path": media_path}
+
     result = _make_api_request("send", method="POST", data=payload, user_id=user_id)
-    
+
     if "error" in result:
         return False, result["error"]
-    
+
     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:
             media_path = audio.convert_to_opus_ogg_temp(media_path)
         except Exception as e:
-            return False, f"Error converting file to opus ogg. You likely need to install ffmpeg: {str(e)}"
-    
-    payload = {
-        "user_id": user_id,
-        "recipient": recipient,
-        "media_path": media_path
-    }
-    
+            return (
+                False,
+                f"Error converting file to opus ogg. You likely need to install ffmpeg: {str(e)}",
+            )
+
+    payload = {"user_id": user_id, "recipient": recipient, "media_path": media_path}
+
     result = _make_api_request("send", method="POST", data=payload, user_id=user_id)
-    
+
     if "error" in result:
         return False, result["error"]
-    
+
     return result.get("success", False), result.get("message", "Unknown response")
 
-def download_media(message_id: str, chat_jid: str, user_id: str = "default_user") -> Optional[str]:
+
+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
-    }
-    
+    payload = {"user_id": user_id, "message_id": message_id, "chat_jid": chat_jid}
+
     result = _make_api_request("download", method="POST", data=payload, user_id=user_id)
-    
+
     if "error" in result:
-        print(f"Download failed: {result['error']}")
         return None
-    
+
     if result.get("success", False):
         path = result.get("path")
-        print(f"Media downloaded successfully: {path}")
         return path
     else:
-        print(f"Download failed: {result.get('message', 'Unknown error')}")
         return None

universal_mcp/applications/whatsapp_business/README.md

@@ -9,26 +9,26 @@ This is automatically generated from OpenAPI schema for the WhatsappBusinessApp
 
 | Tool | Description |
 |------|-------------|
-| `get_analytics` | Retrieves details of a specified WhatsApp Business Account (WABA) with customizable fields using the GET method. |
-| `get_credit_lines` | Retrieves the extended credit lines available for a specified business account using its ID. |
-| `get_business_account` | Retrieves information about a business account using the specified API version and business account ID, optionally filtering the response fields via a query parameter. |
-| `get_commerce_settings` | Retrieves the commerce settings configured for a specific WhatsApp Business phone number. |
-| `set_or_update_commerce_settings` | Updates WhatsApp Business commerce settings (cart availability and catalog visibility) for a specific business phone number. |
-| `upload_file` | Uploads a file using the specified API version and application ID, with optional query parameters for file length and type, and returns a successful status message upon completion. |
-| `resume_session` | Initiates a session using the provided SESSION_ID and file offset specified in the header, supporting further session-related operations via the POST method at the "/{api-version}/<SESSION_ID>" endpoint. |
-| `get_business_phone_number` | Retrieves details for a specific business phone number ID using query parameters to specify returned fields. |
-| `get_all_business_phone_numbers` | Retrieves a list of phone numbers associated with a specific WhatsApp Business Account (WABA), allowing for filtering and customization of the response fields. |
-| `get_qr_code` | Retrieves a message linked to a specific QR code for a business phone number using the GET method via the API. |
-| `delete_qr_code` | Deletes a specific WhatsApp Business QR code using the provided QR code ID and returns a success message if the operation is completed successfully. |
-| `get_all_qr_codes_default_fields` | Retrieves a list of message QR code deep links associated with a business phone number, filtered by specified fields and QR code identifiers. |
-| `create_qr_code` | Creates a WhatsApp Business QR code with a predefined message and returns the generated code details. |
-| `get_template_by_id_default_fields` | Retrieves a template using the specified template ID from the API version path. |
-| `edit_template` | Creates or processes a resource using the specified template ID based on the API version and returns a successful status upon completion. |
-| `get_template_by_name_default_fields` | Retrieves a list of WhatsApp message templates associated with a specific WhatsApp Business Account using the "GET" method, allowing filtering by template name. |
-| `create_message_template` | Creates a new WhatsApp message template for a business account, allowing businesses to send standardized messages to customers. |
-| `delete_template_by_name` | Deletes WhatsApp message templates by name (all languages) or specific ID using query parameters and returns a success status. |
-| `get_subscribed_apps` | Retrieves a list of apps subscribed to webhooks for a WhatsApp Business Account using the GET method. |
-| `subscribe_app_to_waba_swebhooks` | Subscribes an app to webhooks for a WhatsApp Business Account (WABA) using the POST method at the `/subscribed_apps` endpoint, allowing the app to receive updates and notifications from the WABA. |
-| `unsubscribe_apps_by_waba_id` | Unsubscribes an app from webhook notifications for a WhatsApp Business Account. |
-| `get_all_shared_wabas` | Retrieves information about WhatsApp Business accounts associated with a business client, using the specified business account ID and API version. |
-| `get_all_owned_wabas` | Retrieves a list of WhatsApp Business Accounts owned by or shared with the specified business account using a GET request to the given endpoint. |
+| `get_whatsapp_business_account` | Fetches customizable data, primarily analytics, for a specific WhatsApp Business Account (WABA) using its ID. The `fields` parameter allows detailed queries, including date ranges and granularity for metrics like message volume, to refine the returned data. |
+| `get_business_account_credit_lines` | Retrieves the extended credit lines for a specified business account ID. This function fetches billing information by querying the `/extendedcredits` endpoint, returning financial details such as available credit for platform services. |
+| `get_business_account` | Fetches details for a specific Meta Business Account using its ID. This function retrieves the core account object, unlike others that get associated resources like owned/shared WhatsApp Business Accounts (WABAs) or credit lines for the same ID. The response payload can be customized using the 'fields' parameter. |
+| `get_commerce_settings` | Retrieves the commerce settings, such as cart availability and catalog visibility, for a specific WhatsApp Business phone number. This function reads the current configuration, contrasting with `set_or_update_commerce_settings` which modifies them. |
+| `update_commerce_settings` | Updates the commerce settings for a specific business phone number by enabling or disabling cart functionality and catalog visibility. This function differentiates from `get_commerce_settings` by using a POST request to modify data, rather than retrieving it. |
+| `create_upload_session` | Initiates a resumable upload session by providing file metadata (size, type). This function creates an upload session ID and is the first of a two-step process for uploading media, preceding the actual data transfer performed by `resume_session`. |
+| `upload_file_to_session` | Continues a media file upload by sending file data to an existing session. This function is the second step in the upload process, following `upload_file`, which creates the session and provides the required session ID. |
+| `get_business_phone_number` | Retrieves details for a specific WhatsApp Business phone number by its unique ID. The optional `fields` parameter allows for customizing the response to include only desired data, differentiating it from `get_all_business_phone_numbers`, which retrieves a list of all numbers for a WABA. |
+| `list_waba_phone_numbers` | Fetches a list of phone numbers for a specified WhatsApp Business Account (WABA). This function allows for result filtering and customizable field selection, distinguishing it from `get_business_phone_number` which retrieves a single number by its unique ID. |
+| `get_qr_code_by_id` | Retrieves the details of a single QR code, such as its pre-filled message, by its unique ID for a specific business phone number. It fetches a specific code, distinguishing it from `get_all_qr_codes_default_fields` which retrieves a list of codes. |
+| `delete_qr_code_by_id` | Deletes a specific WhatsApp message QR code by its ID for a given business phone number. The function sends a DELETE request to the Graph API's `message_qrdls` endpoint to remove the specified QR code. |
+| `list_qr_codes` | Retrieves a list of QR codes for a business phone number. This function allows optional filtering by a specific QR code identifier and customization of the fields returned in the response, such as the image format. |
+| `create_qr_code` | Generates a WhatsApp Business QR code for a specific phone number. This function allows setting a prefilled message for user convenience and can optionally include a custom identifier. It returns the details of the newly created QR code upon successful generation. |
+| `get_template_by_id` | Retrieves a specific WhatsApp message template by its unique identifier. Unlike `get_template_by_name`, which searches within a business account, this function directly fetches a single template resource. Note: The function signature is missing the required `template_id` parameter to build a valid URL. |
+| `update_template_by_id` | Updates an existing WhatsApp message template, identified by its ID within the request URL. This function modifies the template's category, components, language, and name by submitting new data via a POST request, returning the API response upon successful completion. |
+| `get_message_templates` | Retrieves message templates for a specific WhatsApp Business Account (WABA). It can list all templates or, if a name is provided, filter for an exact match. This differs from `get_template_by_id_default_fields`, which fetches a single template by its unique ID. |
+| `create_message_template` | Creates a new message template for a specified WhatsApp Business Account (WABA). This function sends a POST request with the template's name, language, category, and structural components, enabling the creation of standardized, reusable messages. |
+| `delete_message_template` | Deletes a message template from a WhatsApp Business Account. Templates can be targeted for deletion by providing either a template name, which deletes all language versions, or a specific template ID (`hsm_id`). |
+| `get_subscribed_apps` | Retrieves a list of all applications subscribed to receive webhook notifications for a given WhatsApp Business Account (WABA). This function provides a read-only view of current webhook subscriptions, complementing the functions for subscribing and unsubscribing apps. |
+| `subscribe_app_to_webhooks` | Subscribes an application to a specific WhatsApp Business Account's (WABA) webhooks using its ID. This enables the app to receive real-time event notifications, differentiating it from functions that list or remove subscriptions. |
+| `unsubscribe_app_from_waba` | Removes the webhook subscription for the calling app from a specified WhatsApp Business Account (WABA), stopping it from receiving notifications. This function complements `get_subscribed_apps` and `subscribe_app_to_waba_swebhooks` by handling the deletion of a subscription. |
+| `get_all_client_wabas` | Retrieves all client WhatsApp Business Accounts (WABAs) associated with a specific business account ID. It's used by Solution Partners to list WABAs they manage for other businesses, distinguishing them from accounts they directly own (`get_all_owned_wabas`). |
+| `get_all_owned_wabas` | Retrieves a list of all WhatsApp Business Accounts (WABAs) directly owned by a specified business account. This is distinct from `get_all_shared_wabas`, which fetches WABAs shared with clients, providing specific access to owned assets instead of associated ones. |