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

universal_mcp/applications/linkedin/app.py

@@ -1,6 +1,8 @@
-from typing import Any
-from urllib.parse import quote
+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
 
@@ -10,229 +12,828 @@ class LinkedinApp(APIApplication):
     Base class for Universal MCP Applications.
     """
 
-    def __init__(self, integration: Integration | None = None, **kwargs) -> None:
-        super().__init__(name="linkedin", integration=integration, **kwargs)
-        self.base_url = "https://api.linkedin.com"
+    def __init__(self, integration: Integration) -> None:
+        """
+        Initialize the LinkedinApp.
+
+        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.,
+                         `{"headers": {"x-api-key": "YOUR_API_KEY"}}`.
+        """
+        super().__init__(name="linkedin", integration=integration)
 
-    def _get_headers(self):
+        self._base_url = None
+        self.account_id = None
+        if self.integration:
+            credentials = self.integration.get_credentials()
+            if credentials:
+                self.account_id = credentials.get("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."
+                )
+            self._base_url = f"https://{unipile_dsn}"
+        return self._base_url
+
+    @base_url.setter
+    def base_url(self, base_url: str) -> None:
+        self._base_url = base_url
+        logger.info(f"UnipileApp: Base URL set to {self._base_url}")
+
+    def _get_headers(self) -> dict[str, str]:
+        """
+        Get the headers for Unipile API requests.
+        Overrides the base class method to use X-Api-Key.
+        """
         if not self.integration:
-            raise ValueError("Integration not found")
-        credentials = self.integration.get_credentials()
-        if "headers" in credentials:
-            return credentials["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.debug("UnipileApp: Using X-Api-Key for authentication.")
         return {
-            "Authorization": f"Bearer {credentials['access_token']}",
-            "X-Restli-Protocol-Version": "2.0.0",
+            "x-api-key": api_key,
             "Content-Type": "application/json",
-            "LinkedIn-Version": "202507",
+            "Cache-Control": "no-cache",  # Often good practice for APIs
         }
 
-    def create_post(
+    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 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(
         self,
-        commentary: str,
-        author: str,
-        visibility: str = "PUBLIC",
-        distribution: dict[str, Any] | None = None,
-        lifecycle_state: str = "PUBLISHED",
-        is_reshare_disabled: bool = False,
-    ) -> dict[str, str]:
+        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
+        account_type: str | None = None,
+    ) -> dict[str, Any]:
         """
-        Publishes a new text post to a specified LinkedIn author's feed (person or organization). It requires commentary and allows configuring visibility, distribution, and lifecycle state. Upon success, it returns the unique URN and a direct URL for the newly created post, distinguishing it from update/delete operations.
-        
+        Retrieves a paginated list of all chat conversations across linked accounts. Supports filtering by unread status, date range, and account provider, distinguishing it from functions listing messages within a single chat.
+
         Args:
-            commentary (str): The user generated commentary for the post. Supports mentions using format "@[Entity Name](urn:li:organization:123456)" and hashtags using "#keyword". Text linking to annotated entities must match the name exactly (case sensitive). For member mentions, partial name matching is supported.
-            author (str): The URN of the author creating the post. Use "urn:li:person:{id}" for individual posts or "urn:li:organization:{id}" for company page posts. Example: "urn:li:person:wGgGaX_xbB" or "urn:li:organization:2414183"
-            visibility (str): Controls who can view the post. Use "PUBLIC" for posts viewable by anyone on LinkedIn or "CONNECTIONS" for posts viewable by 1st-degree connections only. Defaults to "PUBLIC".
-            distribution (dict[str, Any], optional): Distribution settings for the post. If not provided, defaults to {"feedDistribution": "MAIN_FEED", "targetEntities": [], "thirdPartyDistributionChannels": []}. feedDistribution controls where the post appears in feeds, targetEntities specifies entities to target, and thirdPartyDistributionChannels defines external distribution channels.
-            lifecycle_state (str): The state of the post. Use "PUBLISHED" for live posts accessible to all entities, "DRAFT" for posts accessible only to author, "PUBLISH_REQUESTED" for posts submitted but processing, or "PUBLISH_FAILED" for posts that failed to publish. Defaults to "PUBLISHED".
-            is_reshare_disabled (bool): Whether resharing is disabled by the author. Set to True to prevent other users from resharing this post, or False to allow resharing. Defaults to False.
-        
+            unread: Filter for unread chats only or read chats only.
+            cursor: Pagination cursor for the next page of entries.
+            before: Filter for items created before this ISO 8601 UTC datetime (exclusive).
+            after: Filter for items created after this ISO 8601 UTC datetime (exclusive).
+            limit: Number of items to return (1-250).
+            account_type: Filter by provider (e.g., "linkedin").
+
         Returns:
-            dict[str, str]: Dictionary containing the post ID with key "post_id". Example: {"post_id": "urn:li:share:6844785523593134080"}
-        
+            A dictionary containing a list of chat objects and a pagination cursor.
+
         Raises:
-            ValueError: If required parameters (commentary, author) are missing or if x-restli-id header is not found
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            linkedin, chat, list, messaging, api
+        """
+        url = f"{self.base_url}/api/v1/chats"
+        params: dict[str, Any] = {}
         
-        Notes:
-            Requires LinkedIn API permissions: w_member_social (for individual posts) or w_organization_social (for company posts). All requests require headers: X-Restli-Protocol-Version: 2.0.0 and LinkedIn-Version: 202507. Rate limits: 150 requests per day per member, 100,000 requests per day per application. The Posts API replaces the deprecated ugcPosts API.
+        params["account_id"] = self.account_id
         
+        if unread is not None:
+            params["unread"] = unread
+        if cursor:
+            params["cursor"] = cursor
+        if before:
+            params["before"] = before
+        if after:
+            params["after"] = after
+        if limit:
+            params["limit"] = limit
+        if account_type:
+            params["account_type"] = account_type
+            
+
+        response = self._get(url, params=params)
+        return response.json()
+
+    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
+        sender_id: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Retrieves messages from a specific chat identified by `chat_id`. Supports pagination and filtering by date or sender. Unlike `list_all_messages`, which fetches from all chats, this function targets the contents of a single conversation.
+
+        Args:
+            chat_id: The ID of the chat to retrieve messages from.
+            cursor: Pagination cursor for the next page of entries.
+            before: Filter for items created before this ISO 8601 UTC datetime (exclusive).
+            after: Filter for items created after this ISO 8601 UTC datetime (exclusive).
+            limit: Number of items to return (1-250).
+            sender_id: Filter messages from a specific sender ID.
+
+        Returns:
+            A dictionary containing a list of message objects and a pagination cursor.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
         Tags:
-            posts, important
-        """
-        # Set default distribution if not provided
-        if distribution is None:
-            distribution = {
-                "feedDistribution": "MAIN_FEED",
-                "targetEntities": [],
-                "thirdPartyDistributionChannels": [],
-            }
+            linkedin, chat, message, list, messaging, api
+        """
+        url = f"{self.base_url}/api/v1/chats/{chat_id}/messages"
+        params: dict[str, Any] = {}
+        if cursor:
+            params["cursor"] = cursor
+        if before:
+            params["before"] = before
+        if after:
+            params["after"] = after
+        if limit:
+            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]:
+        """
+        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.
 
-        request_body_data = {
-            "author": author,
-            "commentary": commentary,
-            "visibility": visibility,
-            "distribution": distribution,
-            "lifecycleState": lifecycle_state,
-            "isReshareDisabledByAuthor": is_reshare_disabled,
+        Args:
+            chat_id: The ID of the chat where the message will be sent.
+            text: The text content of the message.
+            attachments: Optional list of attachment objects to include with the message.
+
+        Returns:
+            A dictionary containing the ID of the sent message.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            linkedin, chat, message, send, create, messaging, api
+        """
+        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]:
+        """
+        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.
+
+        Args:
+            chat_id: The Unipile or provider ID of the chat.
+
+        Returns:
+            A dictionary containing the chat object details.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            linkedin, chat, retrieve, get, messaging, api
+        """
+        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()
+
+    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
+        sender_id: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Retrieves a paginated list of messages from all chats associated with the account. Unlike `list_chat_messages` which targets a specific conversation, this function provides a global message view, filterable by sender and date range.
+
+        Args:
+            cursor: Pagination cursor.
+            before: Filter for items created before this ISO 8601 UTC datetime.
+            after: Filter for items created after this ISO 8601 UTC datetime.
+            limit: Number of items to return (1-250).
+            sender_id: Filter messages from a specific sender.
+
+        Returns:
+            A dictionary containing a list of message objects and a pagination cursor.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            linkedin, message, list, all_messages, messaging, api
+        """
+        url = f"{self.base_url}/api/v1/messages"
+        params: dict[str, Any] = {}
+        if cursor:
+            params["cursor"] = cursor
+        if before:
+            params["before"] = before
+        if after:
+            params["after"] = after
+        if limit:
+            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()
+
+    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,
+    ) -> 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).
+            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.
+
+        Returns:
+            A dictionary containing a list of post objects and pagination details.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        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}
+        if cursor:
+            params["cursor"] = cursor
+        if limit:
+            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]:
+        """
+        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.
+
+        Returns:
+            A dictionary containing the user's profile details.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            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()
+
+    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.
+
+        Args:
+            post_id: The ID of the post to retrieve.
+
+        Returns:
+            A dictionary containing the post details.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            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()
+
+    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'.
+
+        Args:
+            post_id: The social ID of the post.
+            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).
+
+        Returns:
+            A dictionary containing a list of comment objects and pagination details.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            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}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            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,
+    ) -> 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.
+
+        Args:
+            text: The main text content of the post.
+            mentions: Optional list of dictionaries, each representing a mention.
+                      Example: `[{"entity_urn": "urn:li:person:...", "start_index": 0, "end_index": 5}]`
+            external_link: Optional string, an external URL that should be displayed within a card.
+
+        Returns:
+            A dictionary containing the ID of the created post.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            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,
         }
 
-        url = f"{self.base_url}/rest/posts"
-        query_params = {}
+        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,
+    ) -> 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.
+
+        Args:
+            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).
 
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-        )
+        Returns:
+            A dictionary containing a list of reaction objects and pagination details.
 
-        self._handle_response(response)
+        Raises:
+            httpx.HTTPError: If the API request fails.
 
-        post_id = response.headers.get("x-restli-id")
-        if not post_id:
-            raise ValueError("x-restli-id header not found in response")
+        Tags:
+            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}
+        if cursor:
+            params["cursor"] = cursor
+        if limit:
+            params["limit"] = limit
+        if comment_id:
+            params["comment_id"] = comment_id
 
-        return {
-            "post_urn": post_id,
-            "post_url": f"https://www.linkedin.com/feed/update/{post_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,
+    ) -> 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.
+
+        Args:
+            post_social_id: The social ID of the post to comment on.
+            text: The text content of the comment (passed as a query parameter).
+                  Supports Unipile's mention syntax like "Hey {{0}}".
+            comment_id: Optional ID of a specific comment to reply to instead of commenting on the post.
+            mentions_body: Optional list of mention objects for the request body if needed.
+
+        Returns:
+            A dictionary, likely confirming comment creation. (Structure depends on actual API response)
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+
+        Tags:
+            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,
         }
 
-    def get_authenticated_user_profile(self) -> dict[str, Any]:
+        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.",
+            }
+
+    def create_reaction(
+        self,
+        post_social_id: str,
+        reaction_type: Literal[
+            "like", "celebrate", "love", "insightful", "funny", "support"
+        ],
+        comment_id: str | None = None,
+    ) -> dict[str, Any]:
         """
-        Retrieves the authenticated user's profile information from the LinkedIn `/v2/userinfo` endpoint. It returns a dictionary containing the user's basic profile details, such as name and email, using the credentials from the active integration.
-        
+        Adds a specified reaction (e.g., 'like', 'love') to a LinkedIn post or, optionally, to a specific comment. This function performs a POST request to create the reaction, differentiating it from `list_content_reactions` which only retrieves existing ones.
+
+        Args:
+            post_social_id: The social ID of the post or comment to react to.
+            reaction_type: The type of reaction. Valid values are "like", "celebrate", "love", "insightful", "funny", or "support".
+            comment_id: Optional ID of a specific comment to react to instead of the post.
+
         Returns:
-            dict[str, Any]: Dictionary containing your LinkedIn profile information.
-        
+            A dictionary, likely confirming the reaction. (Structure depends on actual API response)
+
         Raises:
-            ValueError: If integration is not found
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body
-        
+            httpx.HTTPError: If the API request fails.
+
         Tags:
-            profile, info
+            linkedin, post, reaction, create, like, content, api, important
         """
-        url = f"{self.base_url}/v2/userinfo"
-        query_params = {}
+        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,
+        }
+
+        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.",
+            }
+
+    def retrieve_user_profile(self, 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".
+
+        Returns:
+            A dictionary containing the user's profile details.
 
-        response = self._get(
-            url,
-            params=query_params,
-        )
+        Raises:
+            httpx.HTTPError: If the API request fails.
 
+        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)
         return self._handle_response(response)
 
-    def delete_post(self, post_urn: str) -> dict[str, str]:
+    def search_people(
+        self,
+        cursor: str | None = None,
+        limit: int | None = None,
+        keywords: str | None = None,
+        location: str | None = None,
+        industry: str | None = None,
+        company: str | None = None,
+    ) -> dict[str, Any]:
         """
-        Deletes a specific LinkedIn post identified by its unique Uniform Resource Name (URN). The function sends a DELETE request to the LinkedIn API and returns a confirmation dictionary with the deletion status upon a successful (HTTP 204) response.
+        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:
-            post_urn (str): The URN of the post to delete. Can be either a ugcPostUrn (urn:li:ugcPost:{id}) or shareUrn (urn:li:share:{id}).
+            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 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:
-            dict[str, str]: Dictionary containing the deletion status. Example: {"status": "deleted", "post_urn": "urn:li:share:6844785523593134080"}
+            A dictionary containing search results and pagination details.
         
         Raises:
-            ValueError: If required parameter (post_urn) is missing or if integration is not found
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body
+            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": "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]
         
-        Tags:
-            posts, important
+        response = self._post(url, params=params, data=payload)
+        return self._handle_response(response)
+
+    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]:
+        """
+        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}/rest/posts/{quote(post_urn, safe='')}"
-        query_params = {}
+        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"}
 
-        response = self._delete(
-            url,
-            params=query_params,
-        )
+        if keywords:
+            payload["keywords"] = keywords
 
-        if response.status_code == 204:
-            return {"status": "deleted", "post_urn": post_urn}
-        else:
-            return self._handle_response(response)
+        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]
 
-    def update_post(
+        response = self._post(url, params=params, data=payload)
+        return self._handle_response(response)
+
+    def search_posts(
         self,
-        post_urn: str,
-        commentary: str | None = None,
-        content_call_to_action_label: str | None = None,
-        content_landing_page: str | None = None,
-        lifecycle_state: str | None = None,
-        ad_context_name: str | None = None,
-        ad_context_status: str | None = None,
-    ) -> dict[str, str]:
+        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]:
         """
-        Modifies an existing LinkedIn post identified by its URN. This function performs a partial update, allowing changes to specific attributes such as commentary, call-to-action details, lifecycle state, or sponsored ad context. It returns a confirmation dictionary upon successful completion of the PATCH request.
+        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:
-            post_urn (str): The URN of the post to update. Can be either a ugcPostUrn (urn:li:ugcPost:{id}) or shareUrn (urn:li:share:{id}).
-            commentary (str | None, optional): The user generated commentary of this post in little format.
-            content_call_to_action_label (str | None, optional): The call to action label that a member can act on that opens a landing page.
-            content_landing_page (str | None, optional): URL of the landing page.
-            lifecycle_state (str | None, optional): The state of the content. Can be DRAFT, PUBLISHED, PUBLISH_REQUESTED, or PUBLISH_FAILED.
-            ad_context_name (str | None, optional): Update the name of the sponsored content.
-            ad_context_status (str | None, optional): Update the status of the sponsored content.
+            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:
-            dict[str, str]: Dictionary containing the update status. Example: {"status": "updated", "post_urn": "urn:li:share:6844785523593134080"}
+            A dictionary containing search results and pagination details.
         
         Raises:
-            ValueError: If required parameter (post_urn) is missing or if integration is not found
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body
-        
+            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)
+
+    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.
         
+        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").
         
+        Returns:
+            A dictionary containing search results and pagination details.
         
-        Tags:
-            posts, update, important
+        Raises:
+            httpx.HTTPError: If the API request fails.
+            ValueError: If the specified location is not found.
         """
-        url = f"{self.base_url}/rest/posts/{quote(post_urn, safe='')}"
-        query_params = {}
-
-        # Build the patch data
-        patch_data = {"$set": {}}
-        ad_context_data = {}
+        url = f"{self.base_url}/api/v1/linkedin/search"
 
-        if commentary is not None:
-            patch_data["$set"]["commentary"] = commentary
-        if content_call_to_action_label is not None:
-            patch_data["$set"]["contentCallToActionLabel"] = (
-                content_call_to_action_label
-            )
-        if content_landing_page is not None:
-            patch_data["$set"]["contentLandingPage"] = content_landing_page
-        if lifecycle_state is not None:
-            patch_data["$set"]["lifecycleState"] = lifecycle_state
+        params: dict[str, Any] = {"account_id": self.account_id}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
 
-        if ad_context_name is not None or ad_context_status is not None:
-            ad_context_data["$set"] = {}
-            if ad_context_name is not None:
-                ad_context_data["$set"]["dscName"] = ad_context_name
-            if ad_context_status is not None:
-                ad_context_data["$set"]["dscStatus"] = ad_context_status
-            patch_data["adContext"] = ad_context_data
+        payload: dict[str, Any] = {
+            "api": "classic",
+            "category": "jobs",
+            "minimum_salary": {
+                "currency": "USD",
+                "value": minimum_salary_value,
+            },
+        }
 
-        request_body_data = {"patch": patch_data}
+        if keywords:
+            payload["keywords"] = keywords
+        if sort_by:
+            payload["sort_by"] = sort_by
 
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-        )
+        # If location is provided, get its ID and add it to the payload
+        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]
 
-        if response.status_code == 204:
-            return {"status": "updated", "post_urn": post_urn}
-        else:
-            return self._handle_response(response)
+        response = self._post(url, params=params, data=payload)
+        return self._handle_response(response)
 
-    def list_tools(self):
-        """
-        Lists the available tools (methods) for this application.
-        """
+    def list_tools(self) -> list[Callable]:
         return [
+            self.list_all_chats,
+            self.list_chat_messages,
+            self.send_chat_message,
+            self.retrieve_chat,
+            self.list_all_messages,
+            self.list_profile_posts,
+            self.retrieve_own_profile,
+            self.retrieve_user_profile,
+            self.retrieve_post,
+            self.list_post_comments,
             self.create_post,
-            self.get_authenticated_user_profile,
-            self.delete_post,
-            self.update_post,
+            self.list_content_reactions,
+            self.create_post_comment,
+            self.create_reaction,
+            self.search_companies,
+            self.search_jobs,
+            self.search_people,
+            self.search_posts,
         ]