universal-mcp-applications 0.1.30rc2__py3-none-any.whl → 0.1.32__py3-none-any.whl

universal_mcp/applications/google_docs/app.py

@@ -11,7 +11,7 @@ class GoogleDocsApp(APIApplication):
 
     def create_document(self, title: str) -> dict[str, Any]:
         """
-        Creates a blank Google Document with a specified title by sending a POST request to the Google Docs API. The function returns a dictionary containing the new document's metadata, including the unique document ID required by other functions for subsequent modifications or retrieval.
+        Creates a blank Google Document with a specified title by sending a POST request to the Google Docs API. The function returns a dictionary containing the new document's metadata, including the unique document ID required by other functions for subsequent modifications or retrieval. Note that you need to call other google_docs functions (e.g. `google_docs__insert_text`) to actually add content after creating the document.
         
         Args:
             title: The title for the new Google Document to be created.
@@ -30,7 +30,11 @@ class GoogleDocsApp(APIApplication):
         document_data = {"title": title}
         response = self._post(url, data=document_data)
         response.raise_for_status()
-        return response.json()
+        payload = response.json()
+        payload["Note"] = (
+            "You must load and call other google docs content functions (like google_docs__insert_text)"
+        )
+        return payload
 
     def get_document(self, document_id: str) -> dict[str, Any]:
         """

universal_mcp/applications/google_sheet/app.py

@@ -21,7 +21,7 @@ class GoogleSheetApp(APIApplication):
 
     def create_spreadsheet(self, title: str) -> dict[str, Any]:
         """
-        Creates a new, blank Google Spreadsheet file with a specified title. This function generates a completely new document, unlike `add_sheet` which adds a worksheet (tab) to an existing spreadsheet. It returns the API response containing the new spreadsheet's metadata.
+        Creates a new, blank Google Spreadsheet file with a specified title. This function generates a completely new document, unlike `add_sheet` which adds a worksheet (tab) to an existing spreadsheet. It returns the API response containing the new spreadsheet's metadata. Note that you need to call other google_sheet functions (e.g. `google_sheet__write_values_to_sheet`) to actually add content after creating the spreadsheet.
 
         Args:
             title: String representing the desired title for the new spreadsheet
@@ -39,7 +39,11 @@ class GoogleSheetApp(APIApplication):
         url = self.base_url
         spreadsheet_data = {"properties": {"title": title}}
         response = self._post(url, data=spreadsheet_data)
-        return self._handle_response(response)
+        payload = self._handle_response(response)
+        payload["Note"] = (
+            "You must load and call other google_sheet content functions (like `google_sheet__write_values_to_sheet`)"
+        )
+        return payload
 
     def get_spreadsheet_metadata(self, spreadsheetId: str) -> dict[str, Any]:
         """

universal_mcp/applications/linkedin/app.py

@@ -78,6 +78,38 @@ class LinkedinApp(APIApplication):
             "Cache-Control": "no-cache",  # Often good practice for APIs
         }
 
+    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,
         unread: bool | None = None,
@@ -271,54 +303,6 @@ class LinkedinApp(APIApplication):
         response = self._get(url, params=params)
         return response.json()
 
-    def list_all_accounts(
-        self,
-        cursor: str | None = None,
-        limit: int | None = None,  # 1-259 according to spec
-    ) -> dict[str, Any]:
-        """
-        Retrieves a paginated list of all social media accounts linked to the Unipile service. This is crucial for obtaining the `account_id` required by other methods to specify which user account should perform an action, like sending a message or retrieving user-specific posts.
-
-        Args:
-            cursor: Pagination cursor.
-            limit: Number of items to return (1-259).
-
-        Returns:
-            A dictionary containing a list of account objects and a pagination cursor.
-
-        Raises:
-            httpx.HTTPError: If the API request fails.
-
-        Tags:
-            linkedin, account, list, unipile, api, important
-        """
-        url = f"{self.base_url}/api/v1/accounts"
-        params: dict[str, Any] = {}
-        if cursor:
-            params["cursor"] = cursor
-        if limit:
-            params["limit"] = limit
-
-        response = self._get(url, params=params)
-        return response.json()
-
-    # def retrieve_linked_account(self) -> dict[str, Any]:
-    #     """
-    #     Retrieves details for the account linked to Unipile. It fetches metadata about the connection itself (e.g., a linked LinkedIn account), differentiating it from `retrieve_user_profile` which fetches a user's profile from the external platform.
-
-    #     Returns:
-    #         A dictionary containing the account object details.
-
-    #     Raises:
-    #         httpx.HTTPError: If the API request fails.
-
-    #     Tags:
-    #         linkedin, account, retrieve, get, unipile, api, important
-    #     """
-    #     url = f"{self.base_url}/api/v1/accounts/{self.account_id}"
-    #     response = self._get(url)
-    #     return response.json()
-
     def list_profile_posts(
         self,
         identifier: str,  # User or Company provider internal ID
@@ -602,43 +586,50 @@ class LinkedinApp(APIApplication):
                 "message": "Reaction action processed.",
             }
 
-    def search(
+    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.
+
+        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 search_people(
         self,
-        category: Literal["people", "companies", "posts", "jobs"],
         cursor: str | None = None,
         limit: int | None = None,
         keywords: str | None = None,
-        date_posted: Literal["past_day", "past_week", "past_month"] | None = None,
-        sort_by: Literal["relevance", "date"] = "relevance",
-        minimum_salary_value: int = 40,
+        location: str | None = None,
+        industry: str | None = None,
+        company: str | None = None,
     ) -> dict[str, Any]:
         """
-        Performs a comprehensive LinkedIn search for people, companies, posts, or jobs using keywords.
-        Supports pagination and targets either the classic or Sales Navigator API for posts.
-        For people, companies, and jobs, it uses the classic API.
-
+        Searches for LinkedIn user profiles using keywords, with optional filters for location, industry, and company. This function specifically targets the 'people' category, distinguishing it from other search methods like `search_companies` or `search_jobs` that query different entity types through the same API endpoint.
+        
         Args:
-            category: Type of search to perform. Valid values are "people", "companies", "posts", or "jobs".
             cursor: Pagination cursor for the next page of entries.
             limit: Number of items to return (up to 50 for Classic search).
             keywords: Keywords to search for.
-            date_posted: Filter by when the post was posted (posts only). Valid values are "past_day", "past_week", or "past_month".
-            sort_by: How to sort the results (for posts and jobs). Valid values are "relevance" or "date".
-            minimum_salary_value: The minimum salary to filter for (jobs only).
-
+        
         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, people, companies, posts, jobs, api, important
         """
-        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}
@@ -647,47 +638,176 @@ class LinkedinApp(APIApplication):
         if limit is not None:
             params["limit"] = limit
 
-        payload: dict[str, Any] = {"api": "classic", "category": category}
+        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 category == "posts":
-            if date_posted:
-                payload["date_posted"] = date_posted
-            if sort_by:
-                payload["sort_by"] = sort_by
+        if industry:
+            industry_id = self._get_search_parameter_id("INDUSTRY", industry)
+            payload["industry"] = [industry_id]
+        
+        if company:
+            company_id = self._get_search_parameter_id("COMPANY", company)
+            payload["company"] = [company_id]
+        
+        response = self._post(url, params=params, data=payload)
+        return self._handle_response(response)
 
-        elif category == "jobs":
-            payload["minimum_salary"] = {
-                "currency": "USD",
-                "value": minimum_salary_value,
-            }
-            if sort_by:
-                payload["sort_by"] = sort_by
+    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.
+        
+        Returns:
+            A dictionary containing search results and pagination details.
+        
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/search"
+
+        params: dict[str, Any] = {"account_id": self.account_id}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+
+        payload: dict[str, Any] = {"api": "classic", "category": "companies"}
+
+        if keywords:
+            payload["keywords"] = keywords
+
+        if location:
+            location_id = self._get_search_parameter_id("LOCATION", location)
+            payload["location"] = [location_id]
+            
+        if industry:
+            industry_id = self._get_search_parameter_id("INDUSTRY", industry)
+            payload["industry"] = [industry_id]
 
         response = self._post(url, params=params, data=payload)
         return self._handle_response(response)
 
-    def retrieve_user_profile(self, identifier: str) -> dict[str, Any]:
+    def search_posts(
+        self,
+        cursor: str | None = None,
+        limit: int | None = None,
+        keywords: str | None = None,
+        date_posted: Literal["past_day", "past_week", "past_month"] | None = None,
+        sort_by: Literal["relevance", "date"] = "relevance",
+    ) -> dict[str, Any]:
         """
-        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.
-
+        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:
-            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".
-
+            cursor: Pagination cursor for the next page of entries.
+            limit: Number of items to return (up to 50 for Classic search).
+            keywords: Keywords to search for.
+            date_posted: Filter by when the post was posted.
+            sort_by: How to sort the results.
+        
         Returns:
-            A dictionary containing the user's profile details.
-
+            A dictionary containing search results and pagination details.
+        
         Raises:
             httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/search"
 
-        Tags:
-            linkedin, user, profile, retrieve, get, api, important
+        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]:
         """
-        url = f"{self.base_url}/api/v1/users/{identifier}"
+        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.
+            location: The geographical location to filter jobs by (e.g., "United States").
+            sort_by: How to sort the results.
+            minimum_salary_value: The minimum salary to filter for.
+        
+        Returns:
+            A dictionary containing search results and pagination details.
+        
+        Raises:
+            httpx.HTTPError: If the API request fails.
+            ValueError: If the specified location is not found.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/search"
+
         params: dict[str, Any] = {"account_id": self.account_id}
-        response = self._get(url, params=params)
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+
+        payload: dict[str, Any] = {
+            "api": "classic",
+            "category": "jobs",
+            "minimum_salary": {
+                "currency": "USD",
+                "value": minimum_salary_value,
+            },
+        }
+
+        if keywords:
+            payload["keywords"] = keywords
+        if sort_by:
+            payload["sort_by"] = sort_by
+
+        # If 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]
+
+        response = self._post(url, params=params, data=payload)
         return self._handle_response(response)
 
     def list_tools(self) -> list[Callable]:
@@ -697,8 +817,6 @@ class LinkedinApp(APIApplication):
             self.send_chat_message,
             self.retrieve_chat,
             self.list_all_messages,
-            self.list_all_accounts,
-            # self.retrieve_linked_account,
             self.list_profile_posts,
             self.retrieve_own_profile,
             self.retrieve_user_profile,
@@ -708,5 +826,8 @@ class LinkedinApp(APIApplication):
             self.list_content_reactions,
             self.create_post_comment,
             self.create_reaction,
-            self.search,
+            self.search_companies,
+            self.search_jobs,
+            self.search_people,
+            self.search_posts,
         ]

universal_mcp/applications/scraper/app.py

@@ -71,72 +71,38 @@ class ScraperApp(APIApplication):
             "Cache-Control": "no-cache",  # Often good practice for APIs
         }
 
-    def linkedin_search(
-        self,
-        category: Literal["people", "companies", "posts", "jobs"],
-        cursor: str | None = None,
-        limit: int | None = None,
-        keywords: str | None = None,
-        date_posted: Literal["past_day", "past_week", "past_month"] | None = None,
-        sort_by: Literal["relevance", "date"] = "relevance",
-        minimum_salary_value: int = 40,
-    ) -> dict[str, Any]:
+    def _get_search_parameter_id(self, param_type: str, keywords: str) -> str:
         """
-        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.
+        Retrieves the ID for a given LinkedIn search parameter by its name.
 
         Args:
-            category: Type of search to perform. Valid values are "people", "companies", "posts", or "jobs".
-            cursor: Pagination cursor for the next page of entries.
-            limit: Number of items to return (up to 50 for Classic search).
-            keywords: Keywords to search for.
-            date_posted: Filter by when the post was posted (posts only). Valid values are "past_day", "past_week", or "past_month".
-            sort_by: How to sort the results (for posts and jobs). Valid values are "relevance" or "date".
-            minimum_salary_value: The minimum salary to filter for (jobs only).
+            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:
-            A dictionary containing search results and pagination details.
+            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.
-            ValueError: If the category is empty.
-
-        Tags:
-            linkedin, search, people, companies, posts, jobs, api, important
         """
-        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
+        url = f"{self.base_url}/api/v1/linkedin/search/parameters"
+        params = {
+            "account_id": self.account_id,
+            "keywords": keywords,
+            "type": param_type,
+        }
 
-        payload: dict[str, Any] = {"api": "classic", "category": category}
+        response = self._get(url, params=params)
+        results = self._handle_response(response)
 
-        if keywords:
-            payload["keywords"] = keywords
+        items = results.get("items", [])
+        if items:
+            # Return the ID of the first result, assuming it's the most relevant
+            return items[0]["id"]
 
-        if category == "posts":
-            if date_posted:
-                payload["date_posted"] = date_posted
-            if sort_by:
-                payload["sort_by"] = sort_by
+        raise ValueError(f'Could not find a matching ID for {param_type}: "{keywords}"')
 
-        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,
@@ -146,20 +112,20 @@ class ScraperApp(APIApplication):
         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.
-
+        Fetches a paginated list of posts from a specific user or company profile using its provider ID. The `is_company` flag must specify the entity type. Unlike `linkedin_search_posts`, this function directly retrieves content from a known profile's feed instead of performing a global keyword search.
+        
         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
         """
@@ -177,17 +143,17 @@ class ScraperApp(APIApplication):
 
     def linkedin_retrieve_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.
-
+        Fetches a specific LinkedIn user's profile using their public or internal ID. Unlike `linkedin_search_people`, which discovers multiple users via keywords, this function targets and retrieves detailed data for a single, known individual based on a direct identifier.
+        
         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.
-
+        
         Raises:
             httpx.HTTPError: If the API request fails.
-
+        
         Tags:
             linkedin, user, profile, retrieve, get, api, important
         """
@@ -204,20 +170,20 @@ class ScraperApp(APIApplication):
         limit: int | None = None,
     ) -> dict[str, Any]:
         """
-        Fetches comments for a specific post. Providing an optional `comment_id` retrieves threaded replies instead of top-level comments. This read-only operation contrasts with `create_post_comment`, which publishes new comments, and `list_content_reactions`, which retrieves 'likes'.
-
+        Fetches a paginated list of comments for a specified LinkedIn post. It can retrieve either top-level comments or threaded replies if an optional `comment_id` is provided. This is a read-only operation, distinct from functions that search for posts or list user-specific content.
+        
         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
         """
@@ -233,6 +199,210 @@ class ScraperApp(APIApplication):
         response = self._get(url, params=params)
         return response.json()
 
+    def linkedin_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]:
+        """
+        Performs a paginated search for people on LinkedIn, distinct from searches for companies or jobs. It filters results using keywords, location, industry, and company, internally converting filter names like 'United States' into their required API IDs before making the request.
+        
+        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.
+        
+        Returns:
+            A dictionary containing search results and pagination details.
+        
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/search"
+
+        params: dict[str, Any] = {"account_id": self.account_id}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+
+        payload: dict[str, Any] = {"api": "classic", "category": "people"}
+
+        if keywords:
+            payload["keywords"] = keywords
+            
+        if location:
+            location_id = self._get_search_parameter_id("LOCATION", location)
+            payload["location"] = [location_id]
+
+        if industry:
+            industry_id = self._get_search_parameter_id("INDUSTRY", industry)
+            payload["industry"] = [industry_id]
+        
+        if company:
+            company_id = self._get_search_parameter_id("COMPANY", company)
+            payload["company"] = [company_id]
+        
+        response = self._post(url, params=params, data=payload)
+        return self._handle_response(response)
+
+    def linkedin_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]:
+        """
+        Executes a paginated LinkedIn search for companies, filtering by optional keywords, location, and industry. Unlike `linkedin_search_people` or `linkedin_search_jobs`, this function specifically sets the API search category to 'companies' to ensure that only company profiles are returned in the search results.
+        
+        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.
+        
+        Returns:
+            A dictionary containing search results and pagination details.
+        
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/search"
+
+        params: dict[str, Any] = {"account_id": self.account_id}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+
+        payload: dict[str, Any] = {"api": "classic", "category": "companies"}
+
+        if keywords:
+            payload["keywords"] = keywords
+
+        if location:
+            location_id = self._get_search_parameter_id("LOCATION", location)
+            payload["location"] = [location_id]
+            
+        if industry:
+            industry_id = self._get_search_parameter_id("INDUSTRY", industry)
+            payload["industry"] = [industry_id]
+
+        response = self._post(url, params=params, data=payload)
+        return self._handle_response(response)
+
+    def linkedin_search_posts(
+        self,
+        cursor: str | None = None,
+        limit: int | None = None,
+        keywords: str | None = None,
+        date_posted: Literal["past_day", "past_week", "past_month"] | None = None,
+        sort_by: Literal["relevance", "date"] = "relevance",
+    ) -> dict[str, Any]:
+        """
+        Performs a keyword-based search for LinkedIn posts, allowing results to be filtered by date and sorted by relevance. This function specifically queries the 'posts' category, distinguishing it from other search methods in the class that target people, companies, or jobs, and returns relevant content.
+        
+        Args:
+            cursor: Pagination cursor for the next page of entries.
+            limit: Number of items to return (up to 50 for Classic search).
+            keywords: Keywords to search for.
+            date_posted: Filter by when the post was posted.
+            sort_by: How to sort the results.
+        
+        Returns:
+            A dictionary containing search results and pagination details.
+        
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/search"
+
+        params: dict[str, Any] = {"account_id": self.account_id}
+        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 linkedin_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]:
+        """
+        Executes a LinkedIn search specifically for job listings using keywords and filters like region, industry, and minimum salary. Unlike other search functions targeting people or companies, this is specialized for job listings and converts friendly filter names (e.g., "United States") into their required API IDs.
+        
+        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 jobs by (e.g., "United States").
+            sort_by: How to sort the results.
+            minimum_salary_value: The minimum salary to filter for.
+        
+        Returns:
+            A dictionary containing search results and pagination details.
+        
+        Raises:
+            httpx.HTTPError: If the API request fails.
+            ValueError: If the specified location is not found.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/search"
+
+        params: dict[str, Any] = {"account_id": self.account_id}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+
+        payload: dict[str, Any] = {
+            "api": "classic",
+            "category": "jobs",
+            "minimum_salary": {
+                "currency": "USD",
+                "value": minimum_salary_value,
+            },
+        }
+
+        if keywords:
+            payload["keywords"] = keywords
+        if sort_by:
+            payload["sort_by"] = sort_by
+
+        # If 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]
+
+        response = self._post(url, params=params, data=payload)
+        return self._handle_response(response)
+
+
     def list_tools(self):
         """
         Returns a list of available tools/functions in this application.
@@ -241,8 +411,11 @@ class ScraperApp(APIApplication):
             A list of functions that can be used as tools.
         """
         return [
-            self.linkedin_search,
             self.linkedin_list_profile_posts,
             self.linkedin_retrieve_profile,
             self.linkedin_list_post_comments,
+            self.linkedin_search_people,
+            self.linkedin_search_companies,
+            self.linkedin_search_posts,
+            self.linkedin_search_jobs,
         ]

universal_mcp/applications/slack/app.py

@@ -9,6 +9,37 @@ class SlackApp(APIApplication):
         super().__init__(name="slack", integration=integration, **kwargs)
         self.base_url = "https://slack.com/api"
 
+    def _get_headers(self) -> dict[str, str]:
+        """
+        Get headers for Slack API requests.
+        Prioritizes user-scoped access token from raw.authed_user.access_token
+        over the bot token at the root level.
+        """
+        if not self.integration:
+            raise ValueError("Integration not configured for SlackApp")
+        
+        credentials = self.integration.get_credentials()
+        if not credentials:
+            raise ValueError("No credentials found for Slack integration")
+        
+        access_token = None
+        raw = credentials.get('raw', {})
+        if isinstance(raw, dict) and 'authed_user' in raw:
+            authed_user = raw.get('authed_user', {})
+            if isinstance(authed_user, dict):
+                access_token = authed_user.get('access_token')
+        
+        if not access_token:
+            access_token = credentials.get('access_token')
+        
+        if not access_token:
+            raise ValueError("Access token not found in Slack credentials")
+        
+        return {
+            "Authorization": f"Bearer {access_token}",
+            "Content-Type": "application/json",
+        }
+
     def chat_delete(
         self,
         as_user: bool | None = None,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-applications
-Version: 0.1.30rc2
+Version: 0.1.32
 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.30rc2.dist-info → universal_mcp_applications-0.1.32.dist-info}/RECORD

@@ -105,7 +105,7 @@ universal_mcp/applications/google_calendar/__init__.py,sha256=qxVxf_Q5lOdxXRHzmE
 universal_mcp/applications/google_calendar/app.py,sha256=FZptXBLsRo4Rp2kRrVJO_dM3Wr8G0XyMXLHWfPya80Q,25884
 universal_mcp/applications/google_docs/README.md,sha256=KDy_X4SRELegE5sEdixAP0YeXZOXdADTX2D-tAUlCJM,4512
 universal_mcp/applications/google_docs/__init__.py,sha256=U0pWagxnj0VD-AcKNd8eS0orzaMmlUOgvW9vkYBNH40,31
-universal_mcp/applications/google_docs/app.py,sha256=V3Ys3D6Al-fYb_8CRj5I5BqcZ0V5ovtHN3eiOHPf07Y,39737
+universal_mcp/applications/google_docs/app.py,sha256=RtAgXXlUHQlKi9MWOGNfPIhWwFMf-o8_R00B78UOYY8,40048
 universal_mcp/applications/google_drive/README.md,sha256=Kmg7LLaDW-7bnsgdVimwxc5SdUf2uA9Fv8zIMXVa-Uc,15393
 universal_mcp/applications/google_drive/__init__.py,sha256=DTyed4ADcCmALSyPT8whjXoosPXl3m-i8JrilPJ3ijU,32
 universal_mcp/applications/google_drive/app.py,sha256=J81m8OBjE0552GGWsIfgM4idFjjZfPEOsjk0ZVeJzgM,257259
@@ -120,7 +120,7 @@ universal_mcp/applications/google_searchconsole/__init__.py,sha256=PHuwQFk0_a-jb
 universal_mcp/applications/google_searchconsole/app.py,sha256=Cb0UiWi6-acWprr5arn_3efW9QHQ4NEiPec4OPeisXk,14040
 universal_mcp/applications/google_sheet/README.md,sha256=ZoKzozYSGDl1AxcVgWkJk2i5uLwB17UaUsVYqo9epqs,7772
 universal_mcp/applications/google_sheet/__init__.py,sha256=sl1VQKQMlYuzZGHUIyVsFvnar6APaIFb4Y_nl7TA0us,32
-universal_mcp/applications/google_sheet/app.py,sha256=LzIXFdGyWmanjYoBo5pZjbEkO8ariyzNeS5QkcVHzTg,87413
+universal_mcp/applications/google_sheet/app.py,sha256=BWCsmVxjTqHPLukA6KODVqQgJ3zghnCjIOVBcaiNYtw,87753
 universal_mcp/applications/google_sheet/helper.py,sha256=rC_2I4oKfd-rpj3UIWXGH4pZlMX1vI9kixryxBFymSY,11996
 universal_mcp/applications/hashnode/README.md,sha256=l0BsLTCS3AeUphVRF2xLWEE0DFPtNBrSNUeaHPcmsx0,1028
 universal_mcp/applications/hashnode/__init__.py,sha256=ty459WmLiNoGM4XZAKWNASp-0MCMBV15J3LstDbZWPw,29
@@ -146,7 +146,7 @@ universal_mcp/applications/klaviyo/__init__.py,sha256=YS2GhW7my_I1tfyLlxlkeTFmlz
 universal_mcp/applications/klaviyo/app.py,sha256=xHQxEZFVIWPCBmL6YoYxuVREibwPRH21izw0psmOzFc,423692
 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/linkedin/app.py,sha256=8pstuCQ88n2QehDAd_FfBaYxlDLF4jbnaGVAr09a8Dc,31988
 universal_mcp/applications/mailchimp/README.md,sha256=xOR32HA8h-WMS9ntcBxyllM3UOBYiyvZ6tJBHlAuU7k,33802
 universal_mcp/applications/mailchimp/__init__.py,sha256=wmXVl-NJyTNkFT5db29OZmeiLWAGu9jXwdZC5o2jZBw,30
 universal_mcp/applications/mailchimp/app.py,sha256=_a6iByjDK1SuM3UoT5lTokptdEryUzrS8JsYNLCTwi4,466723
@@ -197,7 +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=B5toOQGPEoaFHAZXaMbtCu3VsYJLJmtw54cys7c4Lug,9691
+universal_mcp/applications/scraper/app.py,sha256=YKWdxvzWSM9J-zbor0Ty66BfzLQEbdpHybmbgC8Hwhc,16435
 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
@@ -224,7 +224,7 @@ universal_mcp/applications/shortcut/__init__.py,sha256=05TfFUEWxlnh3TmeIdCks1dHb
 universal_mcp/applications/shortcut/app.py,sha256=X-MBMc2mgQgJKKPVbuB9CC5lMpaEm30PSg-rNGwhI2E,172078
 universal_mcp/applications/slack/README.md,sha256=FovYD_aU_NQ6Bj3BPbCk03urDv3UsPu_-7lyeJU4R8I,3634
 universal_mcp/applications/slack/__init__.py,sha256=ch8yJiFaTzKNt0zG6G4n_BpscOFEt1DUrPtXL1K9oIE,26
-universal_mcp/applications/slack/app.py,sha256=ud3YYpjZo8zwCo2vlTetOIfYptFv8dj-EhQl-x__MY8,27331
+universal_mcp/applications/slack/app.py,sha256=LzAWVwbyFzvozfD6HeGTw8M7q3uoLNmxGhqM-Va-SlY,28494
 universal_mcp/applications/spotify/README.md,sha256=pbQbCxPE7vFMQqFzy5kjYLLyJ78KcwZluUHitNC1jAs,9362
 universal_mcp/applications/spotify/__init__.py,sha256=CFdDEEPuXWvfXpwPQxeQ9KN0bTLcnCF6FsA93he8XqA,28
 universal_mcp/applications/spotify/app.py,sha256=BsfOYP87rmJ0Jjjlg9p4z0lKQRPAwsvzWnwMPirJ-Zg,105456
@@ -276,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.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-0.1.32.dist-info/METADATA,sha256=5y-qE3OI4j5463JmNBk5ClM1sYIzwvBbVVG9YVvWWio,2956
+universal_mcp_applications-0.1.32.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp_applications-0.1.32.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
+universal_mcp_applications-0.1.32.dist-info/RECORD,,