universal-mcp-applications 0.1.39rc8__py3-none-any.whl → 0.1.39rc16__py3-none-any.whl

universal_mcp/applications/linkedin/app.py

@@ -20,16 +20,22 @@ 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:
@@ -84,7 +90,7 @@ 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}
+        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", [])
@@ -115,7 +121,7 @@ class LinkedinApp(APIApplication):
             linkedin, chat, create, start, new, messaging, api, important
         """
         url = f"{self.base_url}/api/v1/chats"
-        form_payload = {"account_id": (None, self.account_id), "text": (None, text), "attendees_ids": (None, provider_id)}
+        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.")
@@ -154,7 +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:
@@ -255,8 +261,8 @@ 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
+        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)
 
@@ -299,22 +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
+        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)
 
     async def list_profile_posts(
-        self, identifier: str, cursor: str | None = None, limit: int | None = None, is_company: bool | None = None
+        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.
@@ -325,8 +331,8 @@ 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:
@@ -336,6 +342,33 @@ class LinkedinApp(APIApplication):
         response = await self._aget(url, params=params)
         return self._handle_response(response)
 
+    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.
+
+        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.
@@ -350,7 +383,7 @@ 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}
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
         response = await self._aget(url, params=params)
         return self._handle_response(response)
 
@@ -371,7 +404,7 @@ 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}
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
         response = await self._aget(url, params=params)
         return self._handle_response(response)
 
@@ -397,7 +430,7 @@ 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:
@@ -429,7 +462,7 @@ 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:
@@ -447,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.
@@ -459,7 +492,7 @@ 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:
@@ -492,7 +525,7 @@ 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:
@@ -524,7 +557,7 @@ 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)
@@ -547,7 +580,7 @@ class LinkedinApp(APIApplication):
             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}
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
         response = await self._aget(url, params=params)
         return self._handle_response(response)
 
@@ -578,7 +611,7 @@ class LinkedinApp(APIApplication):
             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:
@@ -623,7 +656,7 @@ class LinkedinApp(APIApplication):
             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:
@@ -665,7 +698,7 @@ class LinkedinApp(APIApplication):
             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:
@@ -710,7 +743,7 @@ class LinkedinApp(APIApplication):
             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:
@@ -753,7 +786,7 @@ class LinkedinApp(APIApplication):
             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}
+        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:
@@ -781,7 +814,7 @@ class LinkedinApp(APIApplication):
             linkedin, user, invite, sent, list, contacts, api
         """
         url = f"{self.base_url}/api/v1/users/invite/sent"
-        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:
@@ -807,7 +840,7 @@ class LinkedinApp(APIApplication):
             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}
+        params: dict[str, Any] = {"account_id": await self._get_account_id()}
         if cursor:
             params["cursor"] = cursor
         if limit is not None:
@@ -836,7 +869,7 @@ class LinkedinApp(APIApplication):
             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}
+        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)
 
@@ -857,7 +890,7 @@ class LinkedinApp(APIApplication):
             linkedin, user, invite, sent, cancel, delete, api
         """
         url = f"{self.base_url}/api/v1/users/invite/sent/{invitation_id}"
-        params = {"account_id": self.account_id}
+        params = {"account_id": await self._get_account_id()}
         response = await self._adelete(url, params=params)
         return self._handle_response(response)
 
@@ -879,7 +912,7 @@ class LinkedinApp(APIApplication):
             linkedin, user, followers, list, contacts, api
         """
         url = f"{self.base_url}/api/v1/users/followers"
-        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:
@@ -905,7 +938,7 @@ class LinkedinApp(APIApplication):
             linkedin, user, following, list, contacts, api
         """
         url = f"{self.base_url}/api/v1/users/following"
-        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:
@@ -913,6 +946,336 @@ class LinkedinApp(APIApplication):
         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.
+
+        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,
@@ -922,6 +1285,7 @@ class LinkedinApp(APIApplication):
             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,
@@ -941,4 +1305,13 @@ class LinkedinApp(APIApplication):
             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,
         ]