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

universal_mcp/applications/linkedin/README.md

@@ -9,7 +9,19 @@ This is automatically generated from OpenAPI schema for the LinkedinApp API.
 
 | Tool | Description |
 |------|-------------|
-| `create_post` | Publishes a new text post to a specified LinkedIn author's feed (person or organization). It allows configuring visibility, distribution, and lifecycle state. Upon success, it returns the unique URN and URL for the new post, distinguishing this creation operation from the update or delete functions. |
-| `get_authenticated_user_profile` | Retrieves the authenticated user's profile from the LinkedIn `/v2/userinfo` endpoint. Using credentials from the active integration, it returns a dictionary with basic user details like name and email. This function is for fetching user data, distinct from others that create, update, or delete posts. |
-| `delete_post` | Deletes a LinkedIn post identified by its unique Uniform Resource Name (URN). This function sends a DELETE request to the API, permanently removing the content. Upon a successful HTTP 204 response, it returns a dictionary confirming the post's deletion status. |
-| `update_post` | Modifies an existing LinkedIn post, identified by its URN, by performing a partial update. It selectively changes attributes like commentary or ad context, distinguishing it from `create_post` which creates new content. Returns a confirmation dictionary upon successful completion. |
+| `list_all_chats` | 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. |
+| `list_chat_messages` | 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. |
+| `send_chat_message` | 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. |
+| `retrieve_chat` | 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. |
+| `list_all_messages` | 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. |
+| `list_all_accounts` | 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. |
+| `list_profile_posts` | 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. |
+| `retrieve_own_profile` | 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. |
+| `retrieve_user_profile` | 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. |
+| `retrieve_post` | 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. |
+| `list_post_comments` | 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'. |
+| `create_post` | 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. |
+| `list_content_reactions` | 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. |
+| `create_post_comment` | 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. |
+| `create_reaction` | 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. |
+| `search` | Performs a comprehensive LinkedIn search for people, companies, posts, or jobs using keywords. |

universal_mcp/applications/scraper/app.py

@@ -1,3 +1,4 @@
+import os
 from dotenv import load_dotenv
 
 load_dotenv()
@@ -8,9 +9,6 @@ from loguru import logger
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 
-from universal_mcp.applications.linkedin import LinkedinApp
-
-
 class ScraperApp(APIApplication):
     """
     Application for interacting with LinkedIn API.
@@ -22,11 +20,56 @@ class ScraperApp(APIApplication):
         if self.integration:
             credentials = self.integration.get_credentials()
             self.account_id = credentials.get("account_id")
-            self._unipile_app = LinkedinApp(integration=self.integration)
         else:
             logger.warning("Integration not found")
             self.account_id = None
-            self._unipile_app = None
+
+    @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:
+            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 {
+            "x-api-key": api_key,
+            "Content-Type": "application/json",
+            "Cache-Control": "no-cache",  # Often good practice for APIs
+        }
 
     def linkedin_search(
         self,
@@ -34,13 +77,15 @@ class ScraperApp(APIApplication):
         cursor: str | None = None,
         limit: int | None = None,
         keywords: str | None = None,
-        date_posted: 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,
     ) -> dict[str, Any]:
         """
-        Performs a general LinkedIn search for posts, people, companies, or jobs using keywords and various filters. This function provides broad, keyword-based discovery across the platform, distinct from other methods that retrieve content from a specific user or company profile. It supports pagination and filtering criteria.
-        
+        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.
+
         Args:
             category: Type of search to perform. Valid values are "people", "companies", "posts", or "jobs".
             cursor: Pagination cursor for the next page of entries.
@@ -49,82 +94,107 @@ class ScraperApp(APIApplication):
             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).
-        
+
         Returns:
             A dictionary containing search results and pagination details.
-        
+
         Raises:
             httpx.HTTPError: If the API request fails.
-        
+            ValueError: If the category is empty.
+
         Tags:
-            linkedin, search, posts, people, companies, api, scrapper, important
+            linkedin, search, people, companies, posts, jobs, api, important
         """
-        return self._unipile_app.search(
-            account_id=self.account_id,
-            category=category,
-            cursor=cursor,
-            limit=limit,
-            keywords=keywords,
-            date_posted=date_posted,
-            sort_by=sort_by,
-            minimum_salary_value=minimum_salary_value,
-        )
+        if not category:
+            raise ValueError("Category cannot be 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": category}
+
+        if keywords:
+            payload["keywords"] = keywords
+
+        if category == "posts":
+            if date_posted:
+                payload["date_posted"] = date_posted
+            if sort_by:
+                payload["sort_by"] = sort_by
+
+        elif category == "jobs":
+            payload["minimum_salary"] = {
+                "currency": "USD",
+                "value": minimum_salary_value,
+            }
+            if sort_by:
+                payload["sort_by"] = sort_by
+
+        response = self._post(url, params=params, data=payload)
+        return self._handle_response(response)
 
     def linkedin_list_profile_posts(
         self,
-        identifier: str,
+        identifier: str,  # User or Company provider internal ID
         cursor: str | None = None,
-        limit: int | None = None,
+        limit: int | None = None,  # 1-100 (spec says max 250)
+        is_company: bool | None = None,
     ) -> dict[str, Any]:
         """
-        Fetches a paginated list of all posts from a specific user or company profile using their unique identifier. This function retrieves content directly from a single profile, unlike the broader, keyword-based `linkedin_search` which searches across the entire LinkedIn platform.
-        
+        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).starts with ACo for users, while for companies it's a series of numbers. You can get it in the results of linkedin_search.
-            cursor: Pagination cursor for the next page of entries.
-            limit: Number of items to return (1-100, though spec allows up to 250).
-        
+            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
         """
-
-        return self._unipile_app.list_profile_posts(
-            identifier=identifier,
-            account_id=self.account_id,
-            cursor=cursor,
-            limit=limit,
-        )
-
-    def linkedin_retrieve_profile(
-        self,
-        identifier: str,
-    ) -> dict[str, Any]:
+        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 linkedin_retrieve_profile(self, identifier: str) -> dict[str, Any]:
         """
-        Retrieves a specific LinkedIn user's profile using their unique identifier (e.g., public username). Unlike other methods that list posts or comments, this function focuses on fetching the user's core profile data by delegating the request to the integrated Unipile application.
-        
+        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: Use the id from linkedin_search results. It starts with ACo for users and is a series of numbers for companies.
-        
+            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.
-        
+
         Raises:
             httpx.HTTPError: If the API request fails.
-        
+
         Tags:
             linkedin, user, profile, retrieve, get, api, important
         """
-
-        return self._unipile_app.retrieve_user_profile(
-            identifier=identifier,
-            account_id=self.account_id,
-        )
+        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 linkedin_list_post_comments(
         self,
@@ -134,31 +204,34 @@ class ScraperApp(APIApplication):
         limit: int | None = None,
     ) -> dict[str, Any]:
         """
-        Fetches a paginated list of comments for a specified LinkedIn post. Providing a `comment_id` retrieves replies to that specific comment instead of top-level ones. This function exclusively targets post interactions, differentiating it from others that list posts or retrieve entire profiles.
-        
+        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. Example urn:li:ugcPost:7386500271624896512
+            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.
-        
+            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
         """
-
-        return self._unipile_app.list_post_comments(
-            post_id=post_id,
-            account_id=self.account_id,
-            comment_id=comment_id,
-            cursor=cursor,
-            limit=limit,
-        )
+        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 list_tools(self):
         """

{universal_mcp_applications-0.1.30rc1.dist-info → universal_mcp_applications-0.1.30rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-applications
-Version: 0.1.30rc1
+Version: 0.1.30rc2
 Summary: A Universal MCP Application: universal_mcp_applications
 Project-URL: Homepage, https://github.com/universal-mcp/applications
 Project-URL: Repository, https://github.com/universal-mcp/applications

{universal_mcp_applications-0.1.30rc1.dist-info → universal_mcp_applications-0.1.30rc2.dist-info}/RECORD

@@ -144,7 +144,7 @@ universal_mcp/applications/jira/app.py,sha256=V9GunK_s4gEuCw6Qnf45lDXaXwjVrNAhWm
 universal_mcp/applications/klaviyo/README.md,sha256=6f2wbhCFF-BbgLr0nEE2Nb-Pz0M0b7U42Dp-ZILXz0I,53609
 universal_mcp/applications/klaviyo/__init__.py,sha256=YS2GhW7my_I1tfyLlxlkeTFmlz2WD8vIpMThtdBflqQ,28
 universal_mcp/applications/klaviyo/app.py,sha256=xHQxEZFVIWPCBmL6YoYxuVREibwPRH21izw0psmOzFc,423692
-universal_mcp/applications/linkedin/README.md,sha256=SYVyzNuADMzYz3ElsA_46qy1tGWlI32WGUfLQ-3PITE,1458
+universal_mcp/applications/linkedin/README.md,sha256=gwbNgrPKUsGzQEsta3kp8SK5RJJ5mPg23WGG548Y6no,4476
 universal_mcp/applications/linkedin/__init__.py,sha256=Yj-713vb4ZYykIlXlwOkKkIXIOB3opCW8wvp_CCqlKk,29
 universal_mcp/applications/linkedin/app.py,sha256=jiKf5A6BwTKeShU0JcSd4Q1iTi282tUqSREyhSPsIIM,27304
 universal_mcp/applications/mailchimp/README.md,sha256=xOR32HA8h-WMS9ntcBxyllM3UOBYiyvZ6tJBHlAuU7k,33802
@@ -197,8 +197,7 @@ universal_mcp/applications/rocketlane/__init__.py,sha256=jl3PjnTvPdjnbFXJgLywSlE
 universal_mcp/applications/rocketlane/app.py,sha256=Ae2hQFI5PylCLtNPJkTqWMLGsLx5fDd4wRFDhxTzTXQ,240689
 universal_mcp/applications/scraper/README.md,sha256=JUNLshHABs4T1f24nvQeee62YIElSkxpU-zs2kuS0Gw,1497
 universal_mcp/applications/scraper/__init__.py,sha256=W5Buzq8QbetUQm5m9xXCHeWcvVObU2vZ4xbvYtZImJo,28
-universal_mcp/applications/scraper/app.py,sha256=-Dgaz_7vykhtdA1BEMHZzyuQMAG-dNsKNiaon-qp2Js,7000
-universal_mcp/applications/scraper/scraper_testers.py,sha256=4OXq1ga7YeM5MmR8J78XdVKWjBX6qiDhBWh04WLXcHY,778
+universal_mcp/applications/scraper/app.py,sha256=B5toOQGPEoaFHAZXaMbtCu3VsYJLJmtw54cys7c4Lug,9691
 universal_mcp/applications/semanticscholar/README.md,sha256=JpLY_698pvstgoNfQ5Go8C8ehQ-o68uFDX5kr86upK0,2834
 universal_mcp/applications/semanticscholar/__init__.py,sha256=eR36chrc0pbBsSE1GadvmQH0OmtKnSC91xbE7HcDPf0,36
 universal_mcp/applications/semanticscholar/app.py,sha256=OHTFkR-IwRU5Rvb1bEu7XmRHikht3hEgZxszLQu6kFI,22234
@@ -277,7 +276,7 @@ universal_mcp/applications/youtube/app.py,sha256=eqgqe0b53W9Mj0FZGW3ZqY3xkGF4NbO
 universal_mcp/applications/zenquotes/README.md,sha256=FJyoTGRCaZjF_bsCBqg1CrYcvIfuUG_Qk616G1wjhF8,512
 universal_mcp/applications/zenquotes/__init__.py,sha256=C5nEHZ3Xy6nYUarq0BqQbbJnHs0UtSlqhk0DqmvWiHk,58
 universal_mcp/applications/zenquotes/app.py,sha256=7xIEnSZWAGYu5583Be2ZjSCtLUAfMWRzucSpp7hw_h4,1299
-universal_mcp_applications-0.1.30rc1.dist-info/METADATA,sha256=vbVhisvEA32Xl7C2a8_HlXSO_y5AhXv8u72hXXqhi7E,2959
-universal_mcp_applications-0.1.30rc1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp_applications-0.1.30rc1.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
-universal_mcp_applications-0.1.30rc1.dist-info/RECORD,,
+universal_mcp_applications-0.1.30rc2.dist-info/METADATA,sha256=i_qlUYtOcqPi-4_uzCUzgFOXmDk4P8SBUThPoWlUKcg,2959
+universal_mcp_applications-0.1.30rc2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp_applications-0.1.30rc2.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
+universal_mcp_applications-0.1.30rc2.dist-info/RECORD,,

universal_mcp/applications/scraper/scraper_testers.py

@@ -1,17 +0,0 @@
-from universal_mcp.applications.scraper import ScraperApp
-
-
-from universal_mcp.agentr import AgentrClient, AgentrRegistry, AgentrIntegration
-
-client = AgentrClient(api_key="key-1f5983ba-f433-4337-b652-dc40f8712660")
-registry = AgentrRegistry(client=client)
-
-integration = AgentrIntegration(name="scraper",client=client)
-
-scraper = ScraperApp(integration=integration)
-
-if __name__ == "__main__":
-    print(scraper.linkedin_search(keywords="ai", limit=2, category="jobs"))
-    # print(scraper.linkedin_retrieve_profile(identifier="ACoAAAEkwwAB9KEc2TrQgOLEQ-vzRyZeCDyc6DQ"))
-    # print(scraper.linkedin_list_profile_posts(identifier="ACoAAAEkwwAB9KEc2TrQgOLEQ-vzRyZeCDyc6DQ", limit=2))
-    # print(scraper.linkedin_list_post_comments(post_id="urn:li:ugcPost:7386500271624896512"))