universal-mcp-applications 0.1.30rc1__py3-none-any.whl → 0.1.36rc1__py3-none-any.whl

universal_mcp/applications/linkedin/app.py

@@ -1,7 +1,6 @@
 import json
 import os
 from typing import Any, Callable, Literal
-
 from loguru import logger
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
@@ -23,7 +22,6 @@ class LinkedinApp(APIApplication):
                          `{"headers": {"x-api-key": "YOUR_API_KEY"}}`.
         """
         super().__init__(name="linkedin", integration=integration)
-
         self._base_url = None
         self.account_id = None
         if self.integration:
@@ -36,12 +34,8 @@ class LinkedinApp(APIApplication):
         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,35 +50,46 @@ 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 list_all_chats(
+    def _get_search_parameter_id(self, param_type: str, keywords: str) -> str:
+        """
+        Retrieves the ID for a given LinkedIn search parameter by its name.
+
+        Args:
+            param_type: The type of parameter to search for (e.g., "LOCATION", "COMPANY").
+            keywords: The name of the parameter to find (e.g., "United States").
+
+        Returns:
+            The corresponding ID for the search parameter.
+
+        Raises:
+            ValueError: If no exact match for the keywords is found.
+            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)
+        results = self._handle_response(response)
+        items = results.get("items", [])
+        if items:
+            return items[0]["id"]
+        raise ValueError(f'Could not find a matching ID for {param_type}: "{keywords}"')
+
+    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]:
         """
@@ -109,9 +114,7 @@ class LinkedinApp(APIApplication):
         """
         url = f"{self.base_url}/api/v1/chats"
         params: dict[str, Any] = {}
-        
         params["account_id"] = self.account_id
-        
         if unread is not None:
             params["unread"] = unread
         if cursor:
@@ -124,18 +127,16 @@ class LinkedinApp(APIApplication):
             params["limit"] = limit
         if account_type:
             params["account_type"] = account_type
-            
-
         response = self._get(url, params=params)
         return response.json()
 
-    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]:
         """
@@ -170,15 +171,10 @@ class LinkedinApp(APIApplication):
             params["limit"] = limit
         if sender_id:
             params["sender_id"] = sender_id
-
         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.
 
@@ -198,11 +194,10 @@ class LinkedinApp(APIApplication):
         """
         url = f"{self.base_url}/api/v1/chats/{chat_id}/messages"
         payload: dict[str, Any] = {"text": text}
-
         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.
 
@@ -222,16 +217,15 @@ class LinkedinApp(APIApplication):
         params: dict[str, Any] = {}
         if self.account_id:
             params["account_id"] = self.account_id
-
         response = self._get(url, params=params)
         return response.json()
 
-    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]:
         """
@@ -267,64 +261,11 @@ class LinkedinApp(APIApplication):
             params["sender_id"] = sender_id
         if self.account_id:
             params["account_id"] = self.account_id
-
         response = self._get(url, params=params)
         return response.json()
 
-    def list_all_accounts(
-        self,
-        cursor: str | None = None,
-        limit: int | None = None,  # 1-259 according to spec
-    ) -> dict[str, Any]:
-        """
-        Retrieves a paginated list of all social media accounts linked to the Unipile service. This is crucial for obtaining the `account_id` required by other methods to specify which user account should perform an action, like sending a message or retrieving user-specific posts.
-
-        Args:
-            cursor: Pagination cursor.
-            limit: Number of items to return (1-259).
-
-        Returns:
-            A dictionary containing a list of account objects and a pagination cursor.
-
-        Raises:
-            httpx.HTTPError: If the API request fails.
-
-        Tags:
-            linkedin, account, list, unipile, api, important
-        """
-        url = f"{self.base_url}/api/v1/accounts"
-        params: dict[str, Any] = {}
-        if cursor:
-            params["cursor"] = cursor
-        if limit:
-            params["limit"] = limit
-
-        response = self._get(url, params=params)
-        return response.json()
-
-    # def retrieve_linked_account(self) -> dict[str, Any]:
-    #     """
-    #     Retrieves details for the account linked to Unipile. It fetches metadata about the connection itself (e.g., a linked LinkedIn account), differentiating it from `retrieve_user_profile` which fetches a user's profile from the external platform.
-
-    #     Returns:
-    #         A dictionary containing the account object details.
-
-    #     Raises:
-    #         httpx.HTTPError: If the API request fails.
-
-    #     Tags:
-    #         linkedin, account, retrieve, get, unipile, api, important
-    #     """
-    #     url = f"{self.base_url}/api/v1/accounts/{self.account_id}"
-    #     response = self._get(url)
-    #     return response.json()
-
-    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, identifier: 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.
@@ -352,11 +293,10 @@ class LinkedinApp(APIApplication):
             params["limit"] = limit
         if is_company is not None:
             params["is_company"] = is_company
-
         response = self._get(url, params=params)
         return response.json()
 
-    def retrieve_own_profile(self) -> dict[str, Any]:
+    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.
 
@@ -374,7 +314,7 @@ class LinkedinApp(APIApplication):
         response = self._get(url, params=params)
         return response.json()
 
-    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.
 
@@ -395,18 +335,14 @@ class LinkedinApp(APIApplication):
         response = self._get(url, params=params)
         return response.json()
 
-    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).
@@ -428,15 +364,11 @@ class LinkedinApp(APIApplication):
             params["limit"] = str(limit)
         if comment_id:
             params["comment_id"] = comment_id
-
         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.
@@ -457,26 +389,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": self.account_id, "text": text}
         if mentions:
             params["mentions"] = mentions
         if external_link:
             params["external_link"] = external_link
-
         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.
@@ -504,16 +426,11 @@ class LinkedinApp(APIApplication):
             params["limit"] = limit
         if comment_id:
             params["comment_id"] = comment_id
-
         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.
@@ -535,33 +452,21 @@ 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": self.account_id, "text": text}
         if comment_id:
             params["comment_id"] = comment_id
-
         if mentions_body:
             params = {"mentions": mentions_body}
-
         response = self._post(url, data=params)
-
         try:
             return response.json()
         except json.JSONDecodeError:
-            return {
-                "status": response.status_code,
-                "message": "Comment action processed.",
-            }
+            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]:
         """
@@ -582,113 +487,382 @@ 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": self.account_id, "post_id": post_social_id, "reaction_type": reaction_type}
         if comment_id:
             params["comment_id"] = comment_id
-
         response = self._post(url, data=params)
-
         try:
             return response.json()
         except json.JSONDecodeError:
-            return {
-                "status": response.status_code,
-                "message": "Reaction action processed.",
-            }
+            return {"status": response.status_code, "message": "Reaction action processed."}
 
-    def search(
+    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:
+            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.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            linkedin, user, profile, retrieve, get, api, important
+        """
+        url = f"{self.base_url}/api/v1/users/{public_identifier}"
+        params: dict[str, Any] = {"account_id": self.account_id}
+        response = self._get(url, params=params)
+        return self._handle_response(response)
+
+    async def search_people(
         self,
-        category: Literal["people", "companies", "posts", "jobs"],
         cursor: str | None = None,
         limit: int | None = None,
         keywords: str | None = None,
-        date_posted: Literal["past_day", "past_week", "past_month"] | None = None,
-        sort_by: Literal["relevance", "date"] = "relevance",
-        minimum_salary_value: int = 40,
+        location: str | None = None,
+        industry: str | None = None,
+        company: str | None = None,
     ) -> dict[str, Any]:
         """
-        Performs a comprehensive LinkedIn search for people, companies, posts, or jobs using keywords.
-        Supports pagination and targets either the classic or Sales Navigator API for posts.
-        For people, companies, and jobs, it uses the classic API.
+        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:
-            category: Type of search to perform. Valid values are "people", "companies", "posts", or "jobs".
             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 (posts only). Valid values are "past_day", "past_week", or "past_month".
-            sort_by: How to sort the results (for posts and jobs). Valid values are "relevance" or "date".
-            minimum_salary_value: The minimum salary to filter for (jobs only).
+            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.
-            ValueError: If the category is empty.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/search"
+        params: dict[str, Any] = {"account_id": self.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)
+            payload["location"] = [location_id]
+        if industry:
+            industry_id = self._get_search_parameter_id("INDUSTRY", industry)
+            payload["industry"] = [industry_id]
+        if company:
+            company_id = self._get_search_parameter_id("COMPANY", company)
+            payload["company"] = [company_id]
+        response = self._post(url, params=params, data=payload)
+        return self._handle_response(response)
 
-        Tags:
-            linkedin, search, people, companies, posts, jobs, api, important
+    async def search_companies(
+        self,
+        cursor: str | None = None,
+        limit: int | None = None,
+        keywords: str | None = None,
+        location: str | None = None,
+        industry: str | None = None,
+    ) -> dict[str, Any]:
         """
-        if not category:
-            raise ValueError("Category cannot be empty.")
+        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.
 
-        url = f"{self.base_url}/api/v1/linkedin/search"
+        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}
         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)
+            payload["location"] = [location_id]
+        if industry:
+            industry_id = self._get_search_parameter_id("INDUSTRY", industry)
+            payload["industry"] = [industry_id]
+        response = self._post(url, params=params, data=payload)
+        return self._handle_response(response)
+
+    async def search_posts(
+        self,
+        cursor: str | None = None,
+        limit: int | None = None,
+        keywords: str | None = None,
+        date_posted: Literal["past_day", "past_week", "past_month"] | None = None,
+        sort_by: Literal["relevance", "date"] = "relevance",
+    ) -> 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.
 
-        payload: dict[str, Any] = {"api": "classic", "category": category}
+        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}
+        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)
+        return self._handle_response(response)
+
+    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,
+        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.
 
-        if category == "posts":
-            if date_posted:
-                payload["date_posted"] = date_posted
-            if sort_by:
-                payload["sort_by"] = sort_by
+        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.
+            industry: The industry to filter jobs by.(e.g., "Software Development").
 
-        elif category == "jobs":
-            payload["minimum_salary"] = {
-                "currency": "USD",
-                "value": minimum_salary_value,
-            }
-            if sort_by:
-                payload["sort_by"] = sort_by
+        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}
+        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},
+        }
+        if keywords:
+            payload["keywords"] = keywords
+        if sort_by:
+            payload["sort_by"] = sort_by
+        if region:
+            location_id = self._get_search_parameter_id("LOCATION", region)
+            payload["region"] = location_id
+        if industry:
+            industry_id = self._get_search_parameter_id("INDUSTRY", industry)
+            payload["industry"] = [industry_id]
         response = self._post(url, params=params, data=payload)
         return self._handle_response(response)
 
-    def retrieve_user_profile(self, identifier: str) -> dict[str, Any]:
+    async def send_invitation(self, provider_id: str, user_email: str | None = None, message: str | None = None) -> 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.
+        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:
-            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".
+            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 containing the user's profile details.
+            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, profile, retrieve, get, api, important
+            linkedin, user, invite, connect, contact, api, important
+        """
+        url = f"{self.base_url}/api/v1/users/invite"
+        payload: dict[str, Any] = {"account_id": self.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 = self._post(url, data=payload)
+        try:
+            return response.json()
+        except json.JSONDecodeError:
+            return {"status": response.status_code, "message": "Invitation action processed."}
+
+    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/{identifier}"
+        url = f"{self.base_url}/api/v1/users/invite/sent"
         params: dict[str, Any] = {"account_id": self.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)
+        return response.json()
+
+    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": self.account_id}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+        response = self._get(url, params=params)
+        return response.json()
+
+    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": self.account_id}
+        response = self._post(url, data=payload)
+        try:
+            return response.json()
+        except json.JSONDecodeError:
+            return {"status": response.status_code, "message": f"Invitation action '{action}' processed."}
+
+    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": self.account_id}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+        response = self._get(url, params=params)
+        return response.json()
+
+    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": self.account_id}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+        response = self._get(url, params=params)
+        return response.json()
 
     def list_tools(self) -> list[Callable]:
         return [
@@ -697,8 +871,6 @@ class LinkedinApp(APIApplication):
             self.send_chat_message,
             self.retrieve_chat,
             self.list_all_messages,
-            self.list_all_accounts,
-            # self.retrieve_linked_account,
             self.list_profile_posts,
             self.retrieve_own_profile,
             self.retrieve_user_profile,
@@ -708,5 +880,13 @@ class LinkedinApp(APIApplication):
             self.list_content_reactions,
             self.create_post_comment,
             self.create_reaction,
-            self.search,
+            self.search_companies,
+            self.search_jobs,
+            self.search_people,
+            self.search_posts,
+            self.send_invitation,
+            self.list_sent_invitations,
+            self.list_received_invitations,
+            self.handle_received_invitation,
+            self.list_followers,
         ]