universal-mcp-applications 0.1.33__py3-none-any.whl → 0.1.39rc16__py3-none-any.whl

universal_mcp/applications/linkedin/app.py

@@ -1,9 +1,10 @@
-import json
 import os
-from typing import Any, Callable, Literal
+from collections.abc import Callable
+from typing import Any, Literal
+import requests
 
 from loguru import logger
-from universal_mcp.applications.application import APIApplication
+from universal_mcp.applications.application import APIApplication, BaseApplication
 from universal_mcp.integrations import Integration
 
 
@@ -19,29 +20,30 @@ class LinkedinApp(APIApplication):
         Args:
             integration: The integration configuration containing credentials and other settings.
                          It is expected that the integration provides the 'x-api-key'
-                         via headers in `integration.get_credentials()`, e.g.,
+                         via headers in `integration.get_credentials_async()`, e.g.,
                          `{"headers": {"x-api-key": "YOUR_API_KEY"}}`.
         """
         super().__init__(name="linkedin", integration=integration)
-
         self._base_url = None
-        self.account_id = None
+        self._account_id = None
+
+    async def _get_account_id(self) -> str | None:
+        if self._account_id:
+            return self._account_id
         if self.integration:
-            credentials = self.integration.get_credentials()
-            if credentials:
-                self.account_id = credentials.get("account_id")
+            credentials = await self.integration.get_credentials_async()
+            self._account_id = credentials.get("account_id")
+        else:
+            logger.warning("Integration not found")
+        return self._account_id
 
     @property
     def base_url(self) -> str:
         if not self._base_url:
             unipile_dsn = os.getenv("UNIPILE_DSN")
             if not unipile_dsn:
-                logger.error(
-                    "UnipileApp: UNIPILE_DSN environment variable is not set."
-                )
-                raise ValueError(
-                    "UnipileApp: UNIPILE_DSN environment variable is required."
-                )
+                logger.error("UnipileApp: UNIPILE_DSN environment variable is not set.")
+                raise ValueError("UnipileApp: UNIPILE_DSN environment variable is required.")
             self._base_url = f"https://{unipile_dsn}"
         return self._base_url
 
@@ -56,31 +58,25 @@ class LinkedinApp(APIApplication):
         Overrides the base class method to use X-Api-Key.
         """
         if not self.integration:
-            logger.warning(
-                "UnipileApp: No integration configured, returning empty headers."
-            )
+            logger.warning("UnipileApp: No integration configured, returning empty headers.")
             return {}
-
         api_key = os.getenv("UNIPILE_API_KEY")
         if not api_key:
-            logger.error(
-                "UnipileApp: API key not found in integration credentials for Unipile."
-            )
-            return {  # Or return minimal headers if some calls might not need auth (unlikely for Unipile)
-                "Content-Type": "application/json",
-                "Cache-Control": "no-cache",
-            }
-
+            logger.error("UnipileApp: API key not found in integration credentials for Unipile.")
+            return {"Content-Type": "application/json", "Cache-Control": "no-cache"}
         logger.debug("UnipileApp: Using X-Api-Key for authentication.")
-        return {
-            "x-api-key": api_key,
-            "Content-Type": "application/json",
-            "Cache-Control": "no-cache",  # Often good practice for APIs
-        }
+        return {"x-api-key": api_key, "Content-Type": "application/json", "Cache-Control": "no-cache"}
 
-    def _get_search_parameter_id(self, param_type: str, keywords: str) -> str:
+    async def _aget_headers(self) -> dict[str, str]:
+        """
+        Get the headers for Unipile API requests asynchronously.
+        Overrides the base class method to use X-Api-Key.
         """
-        Retrieves the ID for a given LinkedIn search parameter by its name.
+        return self._get_headers()
+
+    async def _aget_search_parameter_id(self, param_type: str, keywords: str) -> str:
+        """
+        Retrieves the ID for a given LinkedIn search parameter by its name asynchronously.
 
         Args:
             param_type: The type of parameter to search for (e.g., "LOCATION", "COMPANY").
@@ -94,29 +90,52 @@ class LinkedinApp(APIApplication):
             httpx.HTTPError: If the API request fails.
         """
         url = f"{self.base_url}/api/v1/linkedin/search/parameters"
-        params = {
-            "account_id": self.account_id,
-            "keywords": keywords,
-            "type": param_type,
-        }
-
-        response = self._get(url, params=params)
+        params = {"account_id": await self._get_account_id(), "keywords": keywords, "type": param_type}
+        response = await self._aget(url, params=params)
         results = self._handle_response(response)
-
         items = results.get("items", [])
         if items:
-            # Return the ID of the first result, assuming it's the most relevant
             return items[0]["id"]
-
         raise ValueError(f'Could not find a matching ID for {param_type}: "{keywords}"')
 
-    def list_all_chats(
+    async def start_new_chat(self, provider_id: str, text: str) -> dict[str, Any]:
+        """
+        Starts a new chat conversation with a specified user by sending an initial message.
+        This function constructs a multipart/form-data request using the `files` parameter
+        to ensure correct formatting and headers, working around potential issues in the
+        underlying request method.
+
+        Args:
+            provider_id: The LinkedIn provider ID of the user to start the chat with.
+                        This is available in the response of the `retrieve_user_profile` tool.
+            text: The initial message content. For LinkedIn Recruiter accounts, this can include
+                HTML tags like <strong>, <em>, <a>, <ul>, <ol>, and <li>.
+
+        Returns:
+            A dictionary containing the details of the newly created chat.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            linkedin, chat, create, start, new, messaging, api, important
+        """
+        url = f"{self.base_url}/api/v1/chats"
+        form_payload = {"account_id": (None, await self._get_account_id()), "text": (None, text), "attendees_ids": (None, provider_id)}
+        api_key = os.getenv("UNIPILE_API_KEY")
+        if not api_key:
+            raise ValueError("UNIPILE_API_KEY environment variable is not set.")
+        headers = {"x-api-key": api_key}
+        response = requests.post(url, files=form_payload, headers=headers)
+        return self._handle_response(response)
+
+    async def list_all_chats(
         self,
         unread: bool | None = None,
         cursor: str | None = None,
-        before: str | None = None,  # ISO 8601 UTC datetime
-        after: str | None = None,  # ISO 8601 UTC datetime
-        limit: int | None = None,  # 1-250
+        before: str | None = None,
+        after: str | None = None,
+        limit: int | None = None,
         account_type: str | None = None,
     ) -> dict[str, Any]:
         """
@@ -141,9 +160,7 @@ class LinkedinApp(APIApplication):
         """
         url = f"{self.base_url}/api/v1/chats"
         params: dict[str, Any] = {}
-        
-        params["account_id"] = self.account_id
-        
+        params["account_id"] = await self._get_account_id()
         if unread is not None:
             params["unread"] = unread
         if cursor:
@@ -156,18 +173,16 @@ class LinkedinApp(APIApplication):
             params["limit"] = limit
         if account_type:
             params["account_type"] = account_type
-            
-
-        response = self._get(url, params=params)
-        return response.json()
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
 
-    def list_chat_messages(
+    async def list_chat_messages(
         self,
         chat_id: str,
         cursor: str | None = None,
-        before: str | None = None,  # ISO 8601 UTC datetime
-        after: str | None = None,  # ISO 8601 UTC datetime
-        limit: int | None = None,  # 1-250
+        before: str | None = None,
+        after: str | None = None,
+        limit: int | None = None,
         sender_id: str | None = None,
     ) -> dict[str, Any]:
         """
@@ -202,15 +217,10 @@ class LinkedinApp(APIApplication):
             params["limit"] = limit
         if sender_id:
             params["sender_id"] = sender_id
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
 
-        response = self._get(url, params=params)
-        return response.json()
-
-    def send_chat_message(
-        self,
-        chat_id: str,
-        text: str,
-    ) -> dict[str, Any]:
+    async def send_chat_message(self, chat_id: str, text: str) -> dict[str, Any]:
         """
         Sends a text message to a specific chat conversation using its `chat_id`. This function creates a new message via a POST request, distinguishing it from read-only functions like `list_chat_messages`. It returns the API's response, which typically confirms the successful creation of the message.
 
@@ -230,11 +240,10 @@ class LinkedinApp(APIApplication):
         """
         url = f"{self.base_url}/api/v1/chats/{chat_id}/messages"
         payload: dict[str, Any] = {"text": text}
+        response = await self._apost(url, data=payload)
+        return self._handle_response(response)
 
-        response = self._post(url, data=payload)
-        return response.json()
-
-    def retrieve_chat(self, chat_id: str) -> dict[str, Any]:
+    async def retrieve_chat(self, chat_id: str) -> dict[str, Any]:
         """
         Retrieves a single chat's details using its Unipile or provider-specific ID. This function is distinct from `list_all_chats`, which returns a collection, by targeting one specific conversation.
 
@@ -252,18 +261,17 @@ class LinkedinApp(APIApplication):
         """
         url = f"{self.base_url}/api/v1/chats/{chat_id}"
         params: dict[str, Any] = {}
-        if self.account_id:
-            params["account_id"] = self.account_id
-
-        response = self._get(url, params=params)
-        return response.json()
+        if await self._get_account_id():
+            params["account_id"] = await self._get_account_id()
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
 
-    def list_all_messages(
+    async def list_all_messages(
         self,
         cursor: str | None = None,
-        before: str | None = None,  # ISO 8601 UTC datetime
-        after: str | None = None,  # ISO 8601 UTC datetime
-        limit: int | None = None,  # 1-250
+        before: str | None = None,
+        after: str | None = None,
+        limit: int | None = None,
         sender_id: str | None = None,
     ) -> dict[str, Any]:
         """
@@ -297,27 +305,22 @@ class LinkedinApp(APIApplication):
             params["limit"] = limit
         if sender_id:
             params["sender_id"] = sender_id
-        if self.account_id:
-            params["account_id"] = self.account_id
-
-        response = self._get(url, params=params)
-        return response.json()
+        if await self._get_account_id():
+            params["account_id"] = await self._get_account_id()
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
 
-    def list_profile_posts(
-        self,
-        identifier: str,  # User or Company provider internal ID
-        cursor: str | None = None,
-        limit: int | None = None,  # 1-100 (spec says max 250)
-        is_company: bool | None = None,
+    async def list_profile_posts(
+        self, provider_id: str, cursor: str | None = None, limit: int | None = None, is_company: bool | None = None
     ) -> dict[str, Any]:
         """
         Retrieves a paginated list of posts from a specific user or company profile using their provider ID. An authorizing `account_id` is required, and the `is_company` flag must specify the entity type, distinguishing this from `retrieve_post` which fetches a single post by its own ID.
 
         Args:
-            identifier: The entity's provider internal ID (LinkedIn ID).
+            provider_id: The entity's provider internal ID (LinkedIn ID).
             cursor: Pagination cursor.
-            limit: Number of items to return (1-100, as per Unipile example, though spec allows up to 250).
-            is_company: Boolean indicating if the identifier is for a company.
+            limit: Number of items to return (1-100).
+            is_company: Boolean indicating if the provider_id is for a company.
 
         Returns:
             A dictionary containing a list of post objects and pagination details.
@@ -328,19 +331,45 @@ class LinkedinApp(APIApplication):
         Tags:
             linkedin, post, list, user_posts, company_posts, content, api, important
         """
-        url = f"{self.base_url}/api/v1/users/{identifier}/posts"
-        params: dict[str, Any] = {"account_id": self.account_id}
+        url = f"{self.base_url}/api/v1/users/{provider_id}/posts"
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
         if cursor:
             params["cursor"] = cursor
         if limit:
             params["limit"] = limit
         if is_company is not None:
             params["is_company"] = is_company
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
 
-        response = self._get(url, params=params)
-        return response.json()
+    async def list_profile_comments(self, provider_id: str, limit: int | None = None, cursor: str | None = None) -> dict[str, Any]:
+        """
+        Retrieves a list of comments made by a specific user using their provider ID.
+
+        Args:
+            provider_id: The entity's provider internal ID (LinkedIn ID).
+            limit: Number of items to return (1-100).
+            cursor: Pagination cursor.
+
+        Returns:
+            A dictionary containing the list of comments.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
 
-    def retrieve_own_profile(self) -> dict[str, Any]:
+        Tags:
+            linkedin, user, comments, list, content, api
+        """
+        url = f"{self.base_url}/api/v1/users/{provider_id}/comments"
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
+        if cursor:
+            params["cursor"] = cursor
+        if limit:
+            params["limit"] = limit
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
+
+    async def retrieve_own_profile(self) -> dict[str, Any]:
         """
         Retrieves the profile details for the user associated with the Unipile account. This function targets the API's 'me' endpoint to fetch the authenticated user's profile, distinct from `retrieve_user_profile` which fetches profiles of other users by their public identifier.
 
@@ -354,11 +383,11 @@ class LinkedinApp(APIApplication):
             linkedin, user, profile, me, retrieve, get, api
         """
         url = f"{self.base_url}/api/v1/users/me"
-        params: dict[str, Any] = {"account_id": self.account_id}
-        response = self._get(url, params=params)
-        return response.json()
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
 
-    def retrieve_post(self, post_id: str) -> dict[str, Any]:
+    async def retrieve_post(self, post_id: str) -> dict[str, Any]:
         """
         Fetches a specific post's details by its unique ID. Unlike `list_profile_posts`, which retrieves a collection of posts from a user or company profile, this function targets one specific post and returns its full object.
 
@@ -375,22 +404,18 @@ class LinkedinApp(APIApplication):
             linkedin, post, retrieve, get, content, api, important
         """
         url = f"{self.base_url}/api/v1/posts/{post_id}"
-        params: dict[str, Any] = {"account_id": self.account_id}
-        response = self._get(url, params=params)
-        return response.json()
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
 
-    def list_post_comments(
-        self,
-        post_id: str,
-        comment_id: str | None = None,
-        cursor: str | None = None,
-        limit: int | None = None,
+    async def list_post_comments(
+        self, post_id: str, comment_id: str | None = None, cursor: str | None = None, limit: int | None = None
     ) -> dict[str, Any]:
         """
-        Fetches comments for a specific post. Providing an optional `comment_id` retrieves threaded replies instead of top-level comments. This read-only operation contrasts with `create_post_comment`, which publishes new comments, and `list_content_reactions`, which retrieves 'likes'.
+        Fetches comments for a specific post. Providing an optional `comment_id` retrieves threaded replies instead of top-level comments. `retrieve_post` or `list_profile_posts` can be used to obtain the `post_id` which is the social_id in their response.
 
         Args:
-            post_id: The social ID of the post.
+            post_id: The social ID of the post which you get from using `retrieve_post` or `list_profile_posts` tools.
             comment_id: If provided, retrieves replies to this comment ID instead of top-level comments.
             cursor: Pagination cursor.
             limit: Number of comments to return. (OpenAPI spec shows type string, passed as string if provided).
@@ -405,22 +430,18 @@ class LinkedinApp(APIApplication):
             linkedin, post, comment, list, content, api, important
         """
         url = f"{self.base_url}/api/v1/posts/{post_id}/comments"
-        params: dict[str, Any] = {"account_id": self.account_id}
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
         if cursor:
             params["cursor"] = cursor
         if limit is not None:
             params["limit"] = str(limit)
         if comment_id:
             params["comment_id"] = comment_id
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
 
-        response = self._get(url, params=params)
-        return response.json()
-
-    def create_post(
-        self,
-        text: str,
-        mentions: list[dict[str, Any]] | None = None,
-        external_link: str | None = None,
+    async def create_post(
+        self, text: str, mentions: list[dict[str, Any]] | None = None, external_link: str | None = None
     ) -> dict[str, Any]:
         """
         Publishes a new top-level post from the account, including text, user mentions, and an external link. This function creates original content, distinguishing it from `create_post_comment` which adds replies to existing posts.
@@ -441,26 +462,16 @@ class LinkedinApp(APIApplication):
             linkedin, post, create, share, content, api, important
         """
         url = f"{self.base_url}/api/v1/posts"
-
-        params: dict[str, str] = {
-            "account_id": self.account_id,
-            "text": text,
-        }
-
+        params: dict[str, str] = {"account_id": await self._get_account_id(), "text": text}
         if mentions:
             params["mentions"] = mentions
         if external_link:
             params["external_link"] = external_link
+        response = await self._apost(url, data=params)
+        return self._handle_response(response)
 
-        response = self._post(url, data=params)
-        return response.json()
-
-    def list_content_reactions(
-        self,
-        post_id: str,
-        comment_id: str | None = None,
-        cursor: str | None = None,
-        limit: int | None = None,
+    async def list_content_reactions(
+        self, post_id: str, comment_id: str | None = None, cursor: str | None = None, limit: int | None = None
     ) -> dict[str, Any]:
         """
         Retrieves a paginated list of reactions for a given post or, optionally, a specific comment. This read-only operation uses the account for the request, distinguishing it from the `create_reaction` function which adds new reactions.
@@ -469,7 +480,7 @@ class LinkedinApp(APIApplication):
             post_id: The social ID of the post.
             comment_id: If provided, retrieves reactions for this comment ID.
             cursor: Pagination cursor.
-            limit: Number of reactions to return (1-100, spec max 250).
+            limit: Number of reactions to return (1-100).
 
         Returns:
             A dictionary containing a list of reaction objects and pagination details.
@@ -481,23 +492,18 @@ class LinkedinApp(APIApplication):
             linkedin, post, reaction, list, like, content, api
         """
         url = f"{self.base_url}/api/v1/posts/{post_id}/reactions"
-        params: dict[str, Any] = {"account_id": self.account_id}
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
         if cursor:
             params["cursor"] = cursor
         if limit:
             params["limit"] = limit
         if comment_id:
             params["comment_id"] = comment_id
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
 
-        response = self._get(url, params=params)
-        return response.json()
-
-    def create_post_comment(
-        self,
-        post_social_id: str,
-        text: str,
-        comment_id: str | None = None,  # If provided, replies to a specific comment
-        mentions_body: list[dict[str, Any]] | None = None,
+    async def create_post_comment(
+        self, post_social_id: str, text: str, comment_id: str | None = None, mentions_body: list[dict[str, Any]] | None = None
     ) -> dict[str, Any]:
         """
         Publishes a comment on a specified post. By providing an optional `comment_id`, it creates a threaded reply to an existing comment instead of a new top-level one. This function's dual capability distinguishes it from `list_post_comments`, which only retrieves comments and their replies.
@@ -519,33 +525,18 @@ class LinkedinApp(APIApplication):
             linkedin, post, comment, create, content, api, important
         """
         url = f"{self.base_url}/api/v1/posts/{post_social_id}/comments"
-        params: dict[str, Any] = {
-            "account_id": self.account_id,
-            "text": text,
-        }
-
+        params: dict[str, Any] = {"account_id": await self._get_account_id(), "text": text}
         if comment_id:
             params["comment_id"] = comment_id
-
         if mentions_body:
             params = {"mentions": mentions_body}
+        response = await self._apost(url, data=params)
+        return self._handle_response(response)
 
-        response = self._post(url, data=params)
-
-        try:
-            return response.json()
-        except json.JSONDecodeError:
-            return {
-                "status": response.status_code,
-                "message": "Comment action processed.",
-            }
-
-    def create_reaction(
+    async def create_reaction(
         self,
         post_social_id: str,
-        reaction_type: Literal[
-            "like", "celebrate", "love", "insightful", "funny", "support"
-        ],
+        reaction_type: Literal["like", "celebrate", "love", "insightful", "funny", "support"],
         comment_id: str | None = None,
     ) -> dict[str, Any]:
         """
@@ -566,32 +557,18 @@ class LinkedinApp(APIApplication):
             linkedin, post, reaction, create, like, content, api, important
         """
         url = f"{self.base_url}/api/v1/posts/reaction"
-
-        params: dict[str, str] = {
-            "account_id": self.account_id,
-            "post_id": post_social_id,
-            "reaction_type": reaction_type,
-        }
-
+        params: dict[str, str] = {"account_id": await self._get_account_id(), "post_id": post_social_id, "reaction_type": reaction_type}
         if comment_id:
             params["comment_id"] = comment_id
+        response = await self._apost(url, data=params)
+        return self._handle_response(response)
 
-        response = self._post(url, data=params)
-
-        try:
-            return response.json()
-        except json.JSONDecodeError:
-            return {
-                "status": response.status_code,
-                "message": "Reaction action processed.",
-            }
-
-    def retrieve_user_profile(self, identifier: str) -> dict[str, Any]:
+    async def retrieve_user_profile(self, public_identifier: str) -> dict[str, Any]:
         """
         Retrieves a specific LinkedIn user's profile using their public or internal ID. Unlike `retrieve_own_profile`, which fetches the authenticated user's details, this function targets and returns data for any specified third-party user profile on the platform.
 
         Args:
-            identifier: Can be the provider's internal id OR the provider's public id of the requested user.For example, for https://www.linkedin.com/in/manojbajaj95/, the identifier is "manojbajaj95".
+            public_identifier: Extract this value from the response of `search_people` tool. The response contains a public_identifier field.For example, for https://www.linkedin.com/in/manojbajaj95/, the identifier is "manojbajaj95".
 
         Returns:
             A dictionary containing the user's profile details.
@@ -602,12 +579,12 @@ class LinkedinApp(APIApplication):
         Tags:
             linkedin, user, profile, retrieve, get, api, important
         """
-        url = f"{self.base_url}/api/v1/users/{identifier}"
-        params: dict[str, Any] = {"account_id": self.account_id}
-        response = self._get(url, params=params)
+        url = f"{self.base_url}/api/v1/users/{public_identifier}"
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
+        response = await self._aget(url, params=params)
         return self._handle_response(response)
 
-    def search_people(
+    async def search_people(
         self,
         cursor: str | None = None,
         limit: int | None = None,
@@ -618,7 +595,7 @@ class LinkedinApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Searches for LinkedIn user profiles using keywords, with optional filters for location, industry, and company. This function specifically targets the 'people' category, distinguishing it from other search methods like `search_companies` or `search_jobs` that query different entity types through the same API endpoint.
-        
+
         Args:
             cursor: Pagination cursor for the next page of entries.
             limit: Number of items to return (up to 50 for Classic search).
@@ -626,42 +603,35 @@ class LinkedinApp(APIApplication):
             location: The geographical location to filter people by (e.g., "United States").
             industry: The industry to filter people by.(eg., "Information Technology and Services").
             company: The company to filter people by.(e.g., "Google").
-        
+
         Returns:
             A dictionary containing search results and pagination details.
-        
+
         Raises:
             httpx.HTTPError: If the API request fails.
         """
         url = f"{self.base_url}/api/v1/linkedin/search"
-
-        params: dict[str, Any] = {"account_id": self.account_id}
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
         if cursor:
             params["cursor"] = cursor
         if limit is not None:
             params["limit"] = limit
-
         payload: dict[str, Any] = {"api": "classic", "category": "people"}
-
         if keywords:
             payload["keywords"] = keywords
-            
         if location:
-            location_id = self._get_search_parameter_id("LOCATION", location)
+            location_id = await self._aget_search_parameter_id("LOCATION", location)
             payload["location"] = [location_id]
-
         if industry:
-            industry_id = self._get_search_parameter_id("INDUSTRY", industry)
+            industry_id = await self._aget_search_parameter_id("INDUSTRY", industry)
             payload["industry"] = [industry_id]
-        
         if company:
-            company_id = self._get_search_parameter_id("COMPANY", company)
+            company_id = await self._aget_search_parameter_id("COMPANY", company)
             payload["company"] = [company_id]
-        
-        response = self._post(url, params=params, data=payload)
+        response = await self._apost(url, params=params, data=payload)
         return self._handle_response(response)
 
-    def search_companies(
+    async def search_companies(
         self,
         cursor: str | None = None,
         limit: int | None = None,
@@ -671,45 +641,39 @@ class LinkedinApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Performs a paginated search for companies on LinkedIn using keywords, with optional location and industry filters. Its specific 'companies' search category distinguishes it from other methods like `search_people` or `search_posts`, ensuring that only company profiles are returned.
-        
+
         Args:
             cursor: Pagination cursor for the next page of entries.
             limit: Number of items to return (up to 50 for Classic search).
             keywords: Keywords to search for.
             location: The geographical location to filter companies by (e.g., "United States").
             industry: The industry to filter companies by.(e.g., "Information Technology and Services").
-        
+
         Returns:
             A dictionary containing search results and pagination details.
-        
+
         Raises:
             httpx.HTTPError: If the API request fails.
         """
         url = f"{self.base_url}/api/v1/linkedin/search"
-
-        params: dict[str, Any] = {"account_id": self.account_id}
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
         if cursor:
             params["cursor"] = cursor
         if limit is not None:
             params["limit"] = limit
-
         payload: dict[str, Any] = {"api": "classic", "category": "companies"}
-
         if keywords:
             payload["keywords"] = keywords
-
         if location:
-            location_id = self._get_search_parameter_id("LOCATION", location)
+            location_id = await self._aget_search_parameter_id("LOCATION", location)
             payload["location"] = [location_id]
-            
         if industry:
-            industry_id = self._get_search_parameter_id("INDUSTRY", industry)
+            industry_id = await self._aget_search_parameter_id("INDUSTRY", industry)
             payload["industry"] = [industry_id]
-
-        response = self._post(url, params=params, data=payload)
+        response = await self._apost(url, params=params, data=payload)
         return self._handle_response(response)
 
-    def search_posts(
+    async def search_posts(
         self,
         cursor: str | None = None,
         limit: int | None = None,
@@ -719,111 +683,609 @@ class LinkedinApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Performs a keyword-based search for LinkedIn posts, allowing filters for date and sorting by relevance. This function executes a general, platform-wide content search, distinguishing it from other search functions that target people, companies, or jobs, and from `list_profile_posts` which retrieves from a specific profile.
-        
+
         Args:
             cursor: Pagination cursor for the next page of entries.
             limit: Number of items to return (up to 50 for Classic search).
             keywords: Keywords to search for.
             date_posted: Filter by when the post was posted.
             sort_by: How to sort the results.
-        
+
         Returns:
             A dictionary containing search results and pagination details.
-        
+
         Raises:
             httpx.HTTPError: If the API request fails.
         """
         url = f"{self.base_url}/api/v1/linkedin/search"
-
-        params: dict[str, Any] = {"account_id": self.account_id}
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
         if cursor:
             params["cursor"] = cursor
         if limit is not None:
             params["limit"] = limit
-
         payload: dict[str, Any] = {"api": "classic", "category": "posts"}
-
         if keywords:
             payload["keywords"] = keywords
         if date_posted:
             payload["date_posted"] = date_posted
         if sort_by:
             payload["sort_by"] = sort_by
-
-        response = self._post(url, params=params, data=payload)
+        response = await self._apost(url, params=params, data=payload)
         return self._handle_response(response)
 
-    def search_jobs(
+    async def search_jobs(
         self,
         cursor: str | None = None,
         limit: int | None = None,
         keywords: str | None = None,
         region: str | None = None,
         sort_by: Literal["relevance", "date"] = "relevance",
-        minimum_salary_value: int = 40,
+        minimum_salary_value: Literal[40, 60, 80, 100, 120, 140, 160, 180, 200] = 40,
         industry: str | None = None,
     ) -> dict[str, Any]:
         """
         Performs a LinkedIn search for jobs, filtering results by keywords, region, industry, and minimum salary. Unlike other search functions (`search_people`, `search_companies`), this method is specifically configured to query the 'jobs' category, providing a paginated list of relevant employment opportunities.
-        
+
         Args:
             cursor: Pagination cursor for the next page of entries.
             limit: Number of items to return (up to 50 for Classic search).
             keywords: Keywords to search for.
             region: The geographical region to filter jobs by (e.g., "United States").
             sort_by: How to sort the results.(e.g., "relevance" or "date".)
-            minimum_salary_value: The minimum salary to filter for.
+            minimum_salary_value: The minimum salary to filter for. Allowed values are 40, 60, 80, 100, 120, 140, 160, 180, 200.
             industry: The industry to filter jobs by.(e.g., "Software Development").
-        
+
         Returns:
             A dictionary containing search results and pagination details.
-        
+
         Raises:
             httpx.HTTPError: If the API request fails.
             ValueError: If the specified location is not found.
         """
         url = f"{self.base_url}/api/v1/linkedin/search"
-
-        params: dict[str, Any] = {"account_id": self.account_id}
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
         if cursor:
             params["cursor"] = cursor
         if limit is not None:
             params["limit"] = limit
-
         payload: dict[str, Any] = {
             "api": "classic",
             "category": "jobs",
-            "minimum_salary": {
-                "currency": "USD",
-                "value": minimum_salary_value,
-            },
+            "minimum_salary": {"currency": "USD", "value": minimum_salary_value},
         }
-
         if keywords:
             payload["keywords"] = keywords
         if sort_by:
             payload["sort_by"] = sort_by
-
-        # If location is provided, get its ID and add it to the payload
         if region:
-            location_id = self._get_search_parameter_id("LOCATION", region)
+            location_id = await self._aget_search_parameter_id("LOCATION", region)
             payload["region"] = location_id
-            
         if industry:
-            industry_id = self._get_search_parameter_id("INDUSTRY", industry)
+            industry_id = await self._aget_search_parameter_id("INDUSTRY", industry)
             payload["industry"] = [industry_id]
+        response = await self._apost(url, params=params, data=payload)
+        return self._handle_response(response)
+
+    async def send_invitation(self, provider_id: str, user_email: str | None = None, message: str | None = None) -> dict[str, Any]:
+        """
+        Sends a connection invitation to a LinkedIn user specified by their provider ID. An optional message and the user's email can be included.
+
+        Args:
+            provider_id: The LinkedIn provider ID of the user to invite. This is available in response of `retrieve_user_profile` tool.
+            user_email: Optional. The email address of the user, which may be required by LinkedIn.
+            message: Optional. A personalized message to include with the invitation (max 300 characters).
+
+        Returns:
+            A dictionary confirming the invitation was sent.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+            ValueError: If the message exceeds 300 characters.
+
+        Tags:
+            linkedin, user, invite, connect, contact, api, important
+        """
+        url = f"{self.base_url}/api/v1/users/invite"
+        payload: dict[str, Any] = {"account_id": await self._get_account_id(), "provider_id": provider_id}
+        if user_email:
+            payload["user_email"] = user_email
+        if message:
+            if len(message) > 300:
+                raise ValueError("Message cannot exceed 300 characters.")
+            payload["message"] = message
+        response = await self._apost(url, data=payload)
+        return self._handle_response(response)
+
+    async def list_sent_invitations(self, cursor: str | None = None, limit: int | None = None) -> dict[str, Any]:
+        """
+        Retrieves a paginated list of all sent connection invitations that are currently pending. This function allows for iterating through the history of outstanding connection requests made from the specified account.
+
+        Args:
+            cursor: A pagination cursor for retrieving the next page of entries.
+            limit: The number of items to return, ranging from 1 to 100. Defaults to 10 if not specified.
+
+        Returns:
+            A dictionary containing a list of sent invitation objects and pagination details.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            linkedin, user, invite, sent, list, contacts, api
+        """
+        url = f"{self.base_url}/api/v1/users/invite/sent"
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
+
+    async def list_received_invitations(self, cursor: str | None = None, limit: int | None = None) -> dict[str, Any]:
+        """
+        Retrieves a paginated list of all received connection invitations. This function allows for reviewing and processing incoming connection requests to the specified account.
+
+        Args:
+            cursor: A pagination cursor for retrieving the next page of entries.
+            limit: The number of items to return, ranging from 1 to 100. Defaults to 10 if not specified.
+
+        Returns:
+            A dictionary containing a list of received invitation objects and pagination details.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            linkedin, user, invite, received, list, contacts, api
+        """
+        url = f"{self.base_url}/api/v1/users/invite/received"
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
+
+    async def handle_received_invitation(
+        self, invitation_id: str, action: Literal["accept", "decline"], shared_secret: str
+    ) -> dict[str, Any]:
+        """
+        Accepts or declines a received LinkedIn connection invitation using its ID and a required shared secret. This function performs a POST request to update the invitation's status, distinguishing it from read-only functions like `list_received_invitations`.
+
+        Args:
+            invitation_id: The ID of the invitation to handle.Get this ID from the 'list_received_invitations' tool.
+            action: The action to perform, either "accept" or "decline".
+            shared_secret: The token provided by LinkedIn, retrieved from the 'list_received_invitations' tool, which is mandatory for this action.
+
+        Returns:
+            A dictionary confirming the action was processed.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            linkedin, user, invite, received, handle, accept, decline, api
+        """
+        url = f"{self.base_url}/api/v1/users/invite/received/{invitation_id}"
+        payload: dict[str, Any] = {"provider": "LINKEDIN", "action": action, "shared_secret": shared_secret, "account_id": await self._get_account_id()}
+        response = await self._apost(url, data=payload)
+        return self._handle_response(response)
+
+    async def cancel_sent_invitation(self, invitation_id: str) -> dict[str, Any]:
+        """
+        Cancels a sent LinkedIn connection invitation that is currently pending. This function performs a DELETE request to remove the invitation, withdrawing the connection request.
+
+        Args:
+            invitation_id: The unique ID of the invitation to cancel. This ID can be obtained from the 'list_sent_invitations' tool.
+
+        Returns:
+            A dictionary confirming the invitation was cancelled.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            linkedin, user, invite, sent, cancel, delete, api
+        """
+        url = f"{self.base_url}/api/v1/users/invite/sent/{invitation_id}"
+        params = {"account_id": await self._get_account_id()}
+        response = await self._adelete(url, params=params)
+        return self._handle_response(response)
+
+    async def list_followers(self, cursor: str | None = None, limit: int | None = None) -> dict[str, Any]:
+        """
+        Retrieves a paginated list of all followers for the current user's account. This function is distinct from `list_following` as it shows who follows the user, not who the user follows.
+
+        Args:
+            cursor: A pagination cursor for retrieving the next page of entries.
+            limit: The number of items to return, ranging from 1 to 1000.
+
+        Returns:
+            A dictionary containing a list of follower objects and pagination details.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            linkedin, user, followers, list, contacts, api
+        """
+        url = f"{self.base_url}/api/v1/users/followers"
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
+
+    async def list_following(self, cursor: str | None = None, limit: int | None = None) -> dict[str, Any]:
+        """
+        Retrieves a paginated list of all accounts that the current user is following. This function is the counterpart to `list_followers`, focusing on the user's outgoing connections rather than incoming ones.
+
+        Args:
+            cursor: A pagination cursor for retrieving the next page of entries.
+            limit: The number of items to return, ranging from 1 to 1000.
+
+        Returns:
+            A dictionary containing a list of followed account objects and pagination details.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            linkedin, user, following, list, contacts, api
+        """
+        url = f"{self.base_url}/api/v1/users/following"
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+        response = self._get(url, params=params)
+        return self._handle_response(response)
+
+    async def list_job_postings(
+        self,
+        category: Literal["active", "draft", "closed"] = "active",
+        limit: int | None = None,
+        cursor: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Retrieve the job offers you have posted on LinkedIn whether they are open, closed, or still drafts.
+
+        Args:
+            category: The state of the requested job postings. Default is active.
+            limit: A limit for the number of items returned in the response. The value can be set between 1 and 250.
+            cursor: A cursor for pagination purposes.
+
+        Returns:
+            A dictionary containing a list of job postings and pagination details.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            linkedin, jobs, list, postings, api
+        """
+        url = f"{self.base_url}/api/v1/linkedin/jobs"
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
+        if category:
+            params["category"] = category
+        if limit:
+            params["limit"] = limit
+        if cursor:
+            params["cursor"] = cursor
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
+
+    async def create_job_posting(
+        self,
+        job_title: dict[str, str],
+        company: dict[str, str],
+        workplace: Literal["ON_SITE", "HYBRID", "REMOTE"],
+        location: str,
+        description: str,
+        employment_status: Literal[
+            "FULL_TIME", "PART_TIME", "CONTRACT", "TEMPORARY", "OTHER", "VOLUNTEER", "INTERNSHIP"
+        ] = "FULL_TIME",
+        auto_rejection_template: str | None = None,
+        screening_questions: list[dict[str, Any]] | None = None,
+        recruiter: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """
+        Create a new job offer draft.
+
+        Args:
+            job_title: Required. A dictionary containing either {"id": "..."} or {"text": "..."}.
+            company: Required. A dictionary containing either {"id": "..."} or {"text": "..."}.
+            workplace: Required. One of "ON_SITE", "HYBRID", "REMOTE".
+            location: Required. The ID of the location parameter. Use type LOCATION on the List search parameters route.
+            description: Required. HTML description of the job.
+            employment_status: Optional. One of "FULL_TIME", "PART_TIME", "CONTRACT", "TEMPORARY", "OTHER", "VOLUNTEER", "INTERNSHIP".
+            auto_rejection_template: Optional. A rejection message template.
+            screening_questions: Optional. A list of screening questions.
+            recruiter: Optional. Recruiter object containing:
+                - project: Required. {"id": "..."} or {"name": "..."}.
+                - functions: Required. List of strings (job function IDs).
+                - industries: Required. List of strings (industry IDs).
+                - seniority: Required. Enum (e.g. "INTERNSHIP", "ENTRY_LEVEL", "ASSOCIATE", "MID_SENIOR_LEVEL", "DIRECTOR", "EXECUTIVE", "NOT_APPLICABLE").
+                - apply_method: Required. {"apply_within_linkedin": ...} or {"apply_through_external_website": ...}.
+                - include_poster_info: Optional boolean.
+                - tracking_pixel_url: Optional string.
+                - company_job_id: Optional string.
+                - auto_archive_applicants: Optional object.
+                - send_rejection_notification: Optional boolean.
+
+        Returns:
+            A dictionary containing the response from the API.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/jobs"
+        payload: dict[str, Any] = {
+            "account_id": await self._get_account_id(),
+            "job_title": job_title,
+            "company": company,
+            "workplace": workplace,
+            "location": location,
+            "description": description,
+            "employment_status": employment_status,
+        }
+        if auto_rejection_template:
+            payload["auto_rejection_template"] = auto_rejection_template
+        if screening_questions:
+            payload["screening_questions"] = screening_questions
+        if recruiter:
+            payload["recruiter"] = recruiter
+
+        response = await self._apost(url, data=payload)
+        return self._handle_response(response)
+
+    async def close_job_posting(
+        self,
+        job_id: str,
+        service: Literal["CLASSIC", "RECRUITER"] | None = None,
+    ) -> dict[str, Any]:
+        """
+        Close a job offer you have posted.
+
+        Args:
+            job_id: Required. The ID of the job offer.
+            service: Optional. The Linkedin service the job posting depends on.
+
+        Returns:
+            A dictionary containing the response from the API.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/jobs/{job_id}/close"
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
+        if service:
+            params["service"] = service
+        response = await self._apost(url, params=params, data={})
+        return self._handle_response(response)
+
+    async def retrieve_job_posting(
+        self,
+        job_id: str,
+        service: Literal["CLASSIC", "RECRUITER"] = "CLASSIC",
+    ) -> dict[str, Any]:
+        """
+        Retrieve a job offer.
+
+        Args:
+            job_id: Required. The ID of the job offer.
+            service: Required. The Linkedin service the job posting depends on. Default is CLASSIC.
+
+        Returns:
+            A dictionary containing the job offer details.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/jobs/{job_id}"
+        params: dict[str, Any] = {"account_id": await self._get_account_id(), "service": service}
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
+
+    async def publish_job_posting(
+        self,
+        draft_id: str,
+        mode: Literal["FREE"] = "FREE",
+        service: Literal["CLASSIC", "RECRUITER"] = "CLASSIC",
+        hiring_photo_frame: bool | None = None,
+        bypass_email_verification: bool | None = None,
+    ) -> dict[str, Any]:
+        """
+        Publish the job posting draft you have been working on.
+
+        Args:
+            draft_id: Required. The id of the draft to publish.
+            mode: Required. "FREE".
+            service: Optional. The Linkedin service the job posting depends on. Default is CLASSIC.
+            hiring_photo_frame: Optional. Whether or not to add the hiring photo frame to you profile picture.
+            bypass_email_verification: Optional. Whether or not to verify if you're allowed to post a job on behalf on the current company.
+
+        Returns:
+            A dictionary containing the response from the API.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/jobs/{draft_id}/publish"
+        payload: dict[str, Any] = {
+            "account_id": await self._get_account_id(),
+            "mode": mode,
+            "service": service,
+        }
+        if hiring_photo_frame is not None:
+            payload["hiring_photo_frame"] = hiring_photo_frame
+        if bypass_email_verification is not None:
+            payload["bypass_email_verification"] = bypass_email_verification
+        
+        response = await self._apost(url, data=payload)
+        return self._handle_response(response)
+
+    async def solve_job_publishing_checkpoint(
+        self,
+        draft_id: str,
+        input: str,
+    ) -> dict[str, Any]:
+        """
+        Solve a checkpoint to verify your member privileges.
+
+        Args:
+            draft_id: Required. The id of the draft to solve the checkpoint from.
+            input: Required. The code or input to solve the checkpoint.
+
+        Returns:
+            A dictionary containing the response from the API.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/jobs/{draft_id}/checkpoint"
+        payload: dict[str, Any] = {
+            "account_id": await self._get_account_id(),
+            "input": input,
+        }
+        response = await self._apost(url, data=payload)
+        return self._handle_response(response)
+
+    async def list_job_applicants(
+        self,
+        job_id: str,
+        limit: int = 100,
+        cursor: str | None = None,
+        service: Literal["CLASSIC", "RECRUITER"] = "CLASSIC",
+        sort_by: Literal[
+            "relevance", "alphabetical", "newest_first", "screening_requirements"
+        ]
+        | None = None,
+        keywords: str | None = None,
+        ratings: str | None = None,
+        min_years_in_company: float | None = None,
+        max_years_in_company: float | None = None,
+        min_years_in_position: float | None = None,
+        max_years_in_position: float | None = None,
+        min_years_of_experience: float | None = None,
+        max_years_of_experience: float | None = None,
+    ) -> dict[str, Any]:
+        """
+        Retrieve all the users that have applied to a given offer.
+
+        Args:
+            job_id: Required. The ID of the job offer.
+            limit: Optional. The number of results to return. Default 100.
+            cursor: Optional. The cursor to retrieve the next page.
+            service: Optional. The Linkedin service the job posting depends on. Default is CLASSIC.
+            sort_by: Optional. The sorting rule for applicants. Recruiter only.
+            keywords: Optional. Filter results with keywords.
+            ratings: Optional. One or more ratings (UNRATED, GOOD_FIT, MAYBE, NOT_A_FIT) separated by commas.
+            min_years_in_company: Optional. Linkedin Recruiter native filter.
+            max_years_in_company: Optional. Linkedin Recruiter native filter.
+            min_years_in_position: Optional. Linkedin Recruiter native filter.
+            max_years_in_position: Optional. Linkedin Recruiter native filter.
+            min_years_of_experience: Optional. Linkedin Recruiter native filter.
+            max_years_of_experience: Optional. Linkedin Recruiter native filter.
+
+        Returns:
+            A dictionary containing the list of applicants.
 
-        response = self._post(url, params=params, data=payload)
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/jobs/{job_id}/applicants"
+        params: dict[str, Any] = {
+            "account_id": await self._get_account_id(),
+            "limit": limit,
+            "service": service,
+        }
+        if cursor:
+            params["cursor"] = cursor
+        if sort_by:
+            params["sort_by"] = sort_by
+        if keywords:
+            params["keywords"] = keywords
+        if ratings:
+            params["ratings"] = ratings
+        if min_years_in_company is not None:
+            params["min_years_in_company"] = min_years_in_company
+        if max_years_in_company is not None:
+            params["max_years_in_company"] = max_years_in_company
+        if min_years_in_position is not None:
+            params["min_years_in_position"] = min_years_in_position
+        if max_years_in_position is not None:
+            params["max_years_in_position"] = max_years_in_position
+        if min_years_of_experience is not None:
+            params["min_years_of_experience"] = min_years_of_experience
+        if max_years_of_experience is not None:
+            params["max_years_of_experience"] = max_years_of_experience
+
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
+
+    async def retrieve_job_applicant(
+        self,
+        applicant_id: str,
+    ) -> dict[str, Any]:
+        """
+        Retrieve the details of a user that has applied to a given offer. Applies to Classic job posting only.
+
+        Args:
+            applicant_id: Required. The ID of the applicant.
+
+        Returns:
+            A dictionary containing the applicant details.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/jobs/applicants/{applicant_id}"
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
+
+    async def download_job_applicant_resume(
+        self,
+        applicant_id: str,
+        service: Literal["CLASSIC", "RECRUITER"] = "CLASSIC",
+    ) -> dict[str, Any]:
+        """
+        Download the resume of a job applicant.
+
+        Args:
+            applicant_id: Required. The ID of the job applicant.
+            service: Optional. The Linkedin service the applicant depends on. Default is classic.
+
+        Returns:
+            A dictionary containing the resume details (likely a download URL or binary content, depending on API response).
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/jobs/applicants/{applicant_id}/resume"
+        params: dict[str, Any] = {
+            "account_id": await self._get_account_id(),
+            "service": service,
+        }
+        response = await self._aget(url, params=params)
         return self._handle_response(response)
 
     def list_tools(self) -> list[Callable]:
         return [
+            self.start_new_chat,
             self.list_all_chats,
             self.list_chat_messages,
             self.send_chat_message,
             self.retrieve_chat,
             self.list_all_messages,
             self.list_profile_posts,
+            self.list_profile_comments,
             self.retrieve_own_profile,
             self.retrieve_user_profile,
             self.retrieve_post,
@@ -836,4 +1298,20 @@ class LinkedinApp(APIApplication):
             self.search_jobs,
             self.search_people,
             self.search_posts,
+            self.send_invitation,
+            self.list_sent_invitations,
+            self.cancel_sent_invitation,
+            self.list_received_invitations,
+            self.handle_received_invitation,
+            self.list_followers,
+            # self.list_following       this endpoint is not yet implemented by unipile
+            self.list_job_postings,
+            self.create_job_posting,
+            self.close_job_posting,
+            self.retrieve_job_posting,
+            self.publish_job_posting,
+            self.solve_job_publishing_checkpoint,
+            self.list_job_applicants,
+            self.retrieve_job_applicant,
+            self.download_job_applicant_resume,
         ]