universal-mcp-applications 0.1.1__py3-none-any.whl

universal_mcp/applications/slack/__init__.py

@@ -0,0 +1 @@
+from .app import SlackApp

universal_mcp/applications/slack/app.py

@@ -0,0 +1,570 @@
+from typing import Any
+
+from universal_mcp.applications.application import APIApplication
+from universal_mcp.integrations import Integration
+
+
+class SlackApp(APIApplication):
+    def __init__(self, integration: Integration = None, **kwargs) -> None:
+        super().__init__(name="slack", integration=integration, **kwargs)
+        self.base_url = "https://slack.com/api"
+
+    def chat_delete(
+        self,
+        as_user: bool | None = None,
+        channel: str | None = None,
+        ts: float | None = None,
+    ) -> dict[str, Any]:
+        """
+        Deletes a message from a Slack channel using the provided token and returns a status message.
+
+        Args:
+            as_user (boolean): Pass true to delete the message as the authed user with `chat:write:user` scope. [Bot users](https://slack.dev) in this context are considered authed users. If unused or false, the message will be deleted with `chat:write:bot` scope.
+            channel (string): Channel containing the message to be deleted.
+            ts (number): Timestamp of the message to be deleted.
+
+        Returns:
+            dict[str, Any]: Typical success response
+
+        Raises:
+            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+
+        Tags:
+            chat
+        """
+        request_body_data = None
+        request_body_data = {
+            "as_user": as_user,
+            "channel": channel,
+            "ts": ts,
+        }
+        request_body_data = {
+            k: v for k, v in request_body_data.items() if v is not None
+        }
+        url = f"{self.base_url}/chat.delete"
+        query_params = {}
+        response = self._post(
+            url,
+            data=request_body_data,
+            params=query_params,
+            content_type="application/x-www-form-urlencoded",
+        )
+        return self._handle_response(response)
+
+    def chat_post_message(
+        self,
+        as_user: bool | None = None,
+        attachments: str | None = None,
+        blocks: str | None = None,
+        channel: str | None = None,
+        icon_emoji: str | None = None,
+        icon_url: str | None = None,
+        link_names: bool | None = None,
+        mrkdwn: bool | None = None,
+        parse: str | None = None,
+        reply_broadcast: bool | None = None,
+        text: str | None = None,
+        thread_ts: str | None = None,
+        unfurl_links: bool | None = None,
+        unfurl_media: bool | None = None,
+        username: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Sends a message to a Slack channel using the `chat.postMessage` method, which requires a valid authentication token and supports various message formats, including text, attachments, and blocks.
+
+        Args:
+            as_user (boolean): Pass true to post the message as the authed user, instead of as a bot. Defaults to false. See [authorship](https://slack.dev) below.
+            attachments (string): A JSON-based array of structured attachments, presented as a URL-encoded string.
+            blocks (string): A JSON-based array of structured blocks, presented as a URL-encoded string.
+            channel (string): Channel, private group, or IM channel to send message to. Can be an encoded ID, or a name. See [below](https://slack.dev) for more details.
+            icon_emoji (string): Emoji to use as the icon for this message. Overrides `icon_url`. Must be used in conjunction with `as_user` set to `false`, otherwise ignored. See [authorship](https://slack.dev) below.
+            icon_url (string): URL to an image to use as the icon for this message. Must be used in conjunction with `as_user` set to false, otherwise ignored. See [authorship](https://slack.dev) below.
+            link_names (boolean): Find and link channel names and usernames.
+            mrkdwn (boolean): Disable Slack markup parsing by setting to `false`. Enabled by default.
+            parse (string): Change how messages are treated. Defaults to `none`. See [below](https://slack.dev).
+            reply_broadcast (boolean): Used in conjunction with `thread_ts` and indicates whether reply should be made visible to everyone in the channel or conversation. Defaults to `false`.
+            text (string): How this field works and whether it is required depends on other fields you use in your API call. [See below](https://slack.dev) for more detail.
+            thread_ts (string): Provide another message's `ts` value to make this message a reply. Avoid using a reply's `ts` value; use its parent instead.
+            unfurl_links (boolean): Pass true to enable unfurling of primarily text-based content.
+            unfurl_media (boolean): Pass false to disable unfurling of media content.
+            username (string): Set your bot's user name. Must be used in conjunction with `as_user` set to false, otherwise ignored. See [authorship](https://slack.dev) below.
+
+        Returns:
+            dict[str, Any]: Typical success response
+
+        Raises:
+            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+
+        Tags:
+            chat
+        """
+        request_body_data = None
+        request_body_data = {
+            "as_user": as_user,
+            "attachments": attachments,
+            "blocks": blocks,
+            "channel": channel,
+            "icon_emoji": icon_emoji,
+            "icon_url": icon_url,
+            "link_names": link_names,
+            "mrkdwn": mrkdwn,
+            "parse": parse,
+            "reply_broadcast": reply_broadcast,
+            "text": text,
+            "thread_ts": thread_ts,
+            "unfurl_links": unfurl_links,
+            "unfurl_media": unfurl_media,
+            "username": username,
+        }
+        request_body_data = {
+            k: v for k, v in request_body_data.items() if v is not None
+        }
+        url = f"{self.base_url}/chat.postMessage"
+        query_params = {}
+        response = self._post(
+            url,
+            data=request_body_data,
+            params=query_params,
+            content_type="application/x-www-form-urlencoded",
+        )
+        return self._handle_response(response)
+
+    def chat_update(
+        self,
+        as_user: str | None = None,
+        attachments: str | None = None,
+        blocks: str | None = None,
+        channel: str | None = None,
+        link_names: str | None = None,
+        parse: str | None = None,
+        text: str | None = None,
+        ts: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Updates a message in a Slack channel using the "chat.update" API method, requiring a valid authentication token and supporting modifications to message content through parameters like "text," "blocks," or "attachments."
+
+        Args:
+            as_user (string): Pass true to update the message as the authed user. [Bot users](https://slack.dev) in this context are considered authed users.
+            attachments (string): A JSON-based array of structured attachments, presented as a URL-encoded string. This field is required when not presenting `text`. If you don't include this field, the message's previous `attachments` will be retained. To remove previous `attachments`, include an empty array for this field.
+            blocks (string): A JSON-based array of [structured blocks](https://slack.dev), presented as a URL-encoded string. If you don't include this field, the message's previous `blocks` will be retained. To remove previous `blocks`, include an empty array for this field.
+            channel (string): Channel containing the message to be updated.
+            link_names (string): Find and link channel names and usernames. Defaults to `none`. If you do not specify a value for this field, the original value set for the message will be overwritten with the default, `none`.
+            parse (string): Change how messages are treated. Defaults to `client`, unlike `chat.postMessage`. Accepts either `none` or `full`. If you do not specify a value for this field, the original value set for the message will be overwritten with the default, `client`.
+            text (string): New text for the message, using the [default formatting rules](https://slack.dev). It's not required when presenting `blocks` or `attachments`.
+            ts (string): Timestamp of the message to be updated.
+
+        Returns:
+            dict[str, Any]: Typical success response
+
+        Raises:
+            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+
+        Tags:
+            chat
+        """
+        request_body_data = None
+        request_body_data = {
+            "as_user": as_user,
+            "attachments": attachments,
+            "blocks": blocks,
+            "channel": channel,
+            "link_names": link_names,
+            "parse": parse,
+            "text": text,
+            "ts": ts,
+        }
+        request_body_data = {
+            k: v for k, v in request_body_data.items() if v is not None
+        }
+        url = f"{self.base_url}/chat.update"
+        query_params = {}
+        response = self._post(
+            url,
+            data=request_body_data,
+            params=query_params,
+            content_type="application/x-www-form-urlencoded",
+        )
+        return self._handle_response(response)
+
+    def conversations_history(
+        self,
+        token: str | None = None,
+        channel: str | None = None,
+        latest: float | None = None,
+        oldest: float | None = None,
+        inclusive: bool | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Retrieves a portion of message events from a specified Slack conversation using the `conversations.history` method, allowing for pagination and filtering by timestamp.
+
+        Args:
+            token (string): Authentication token used to access conversation history.
+            channel (string): The ID of the channel to retrieve the conversation history from.
+            latest (number): Specifies the number of the latest conversation messages to retrieve from the history.
+            oldest (number): Timestamp (in seconds) of the oldest message to include in the conversation history results.
+            inclusive (boolean): Determines whether to include the messages at the end of the history range in the response.
+            limit (integer): Specifies the maximum number of conversation history entries to retrieve in a single API call.
+            cursor (string): A string token used for cursor-based pagination to fetch the next set of conversation history results starting from a specific point.
+
+        Returns:
+            dict[str, Any]: Typical success response containing a channel's messages
+
+        Raises:
+            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+
+        Tags:
+            conversations
+        """
+        url = f"{self.base_url}/conversations.history"
+        query_params = {
+            k: v
+            for k, v in [
+                ("token", token),
+                ("channel", channel),
+                ("latest", latest),
+                ("oldest", oldest),
+                ("inclusive", inclusive),
+                ("limit", limit),
+                ("cursor", cursor),
+            ]
+            if v is not None
+        }
+        response = self._get(url, params=query_params)
+        return self._handle_response(response)
+
+    def conversations_list(
+        self,
+        token: str | None = None,
+        exclude_archived: bool | None = None,
+        types: str | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Retrieves a list of all channel-like conversations in a Slack workspace, optionally excluding archived channels and supporting pagination using a cursor[1][2][3].
+
+        Args:
+            token (string): The token parameter in the query string is a string used for authentication to authorize and identify the client making the GET request to the /conversations.list endpoint.
+            exclude_archived (boolean): Exclude archived conversations from the list of results.
+            types (string): Specifies the types of conversations to include in the list, as a string query parameter.
+            limit (integer): Specifies the maximum number of conversations to return in the response, with a default value of 1.
+            cursor (string): A cursor string used for pagination to specify the position from which to continue retrieving the next set of conversation results.
+
+        Returns:
+            dict[str, Any]: Typical success response with only public channels
+
+        Raises:
+            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+
+        Tags:
+            conversations
+        """
+        url = f"{self.base_url}/conversations.list"
+        query_params = {
+            k: v
+            for k, v in [
+                ("token", token),
+                ("exclude_archived", exclude_archived),
+                ("types", types),
+                ("limit", limit),
+                ("cursor", cursor),
+            ]
+            if v is not None
+        }
+        response = self._get(url, params=query_params)
+        return self._handle_response(response)
+
+    def reactions_add(self, channel: str, name: str, timestamp: str) -> dict[str, Any]:
+        """
+        Adds a reaction to an item in Slack using a POST request with an authorization token and required form data.
+
+        Args:
+            channel (string): Channel where the message to add reaction to was posted.
+            name (string): Reaction (emoji) name.
+            timestamp (string): Timestamp of the message to add reaction to.
+
+        Returns:
+            dict[str, Any]: Typical success response
+
+        Raises:
+            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+
+        Tags:
+            reactions
+        """
+        request_body_data = None
+        request_body_data = {
+            "channel": channel,
+            "name": name,
+            "timestamp": timestamp,
+        }
+        request_body_data = {
+            k: v for k, v in request_body_data.items() if v is not None
+        }
+        url = f"{self.base_url}/reactions.add"
+        query_params = {}
+        response = self._post(
+            url,
+            data=request_body_data,
+            params=query_params,
+            content_type="application/x-www-form-urlencoded",
+        )
+        return self._handle_response(response)
+
+    def reactions_get(
+        self,
+        token: str,
+        channel: str | None = None,
+        file: str | None = None,
+        file_comment: str | None = None,
+        full: bool | None = None,
+        timestamp: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Retrieves reaction information for a Slack message or file based on specified parameters such as channel, file, file comment, or timestamp, requiring a valid token with "reactions:read" scope.
+
+        Args:
+            token (string): The "token" parameter is a required string that must be provided in the query string for authentication purposes when using the GET operation at "/reactions.get" to authorize access to reaction data.
+            channel (string): The channel identifier to filter reactions by, specified as a string.
+            file (string): The file parameter specifies the identifier of the file for which to retrieve reactions.
+            file_comment (string): A query parameter to filter reactions by a specific file comment.
+            full (boolean): Whether to return full reaction details or only basic reaction information.
+            timestamp (string): The timestamp parameter filters results based on a specific date and time value, expected in an ISO 8601 format string.
+
+        Returns:
+            dict[str, Any]: Typical success response
+
+        Raises:
+            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+
+        Tags:
+            reactions
+        """
+        url = f"{self.base_url}/reactions.get"
+        query_params = {
+            k: v
+            for k, v in [
+                ("token", token),
+                ("channel", channel),
+                ("file", file),
+                ("file_comment", file_comment),
+                ("full", full),
+                ("timestamp", timestamp),
+            ]
+            if v is not None
+        }
+        response = self._get(url, params=query_params)
+        return self._handle_response(response)
+
+    def reactions_list(
+        self,
+        token: str,
+        user: str | None = None,
+        full: bool | None = None,
+        count: int | None = None,
+        page: int | None = None,
+        cursor: str | None = None,
+        limit: int | None = None,
+    ) -> dict[str, Any]:
+        """
+        Retrieves a paginated list of reactions, supporting filtering by user and additional query parameters for granular results.
+
+        Args:
+            token (string): Required authentication token passed as a query parameter to authenticate the request for listing reactions.
+            user (string): Filter reactions by specifying the user, which can be a username or identifier.
+            full (boolean): Indicates whether to retrieve a full list of reactions, with `true` returning all reactions and `false` returning a partial list.
+            count (integer): The "count" query parameter specifies the maximum number of reaction items to return in the response.
+            page (integer): The "page" parameter is an integer query parameter used to specify the page number for pagination in the list of reactions.
+            cursor (string): A string used to specify the position in the list of reactions for pagination, allowing retrieval of additional items after or before the specified cursor.
+            limit (integer): The `limit` parameter specifies the maximum number of reactions to return in the response.
+
+        Returns:
+            dict[str, Any]: Typical success response
+
+        Raises:
+            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+
+        Tags:
+            reactions
+        """
+        url = f"{self.base_url}/reactions.list"
+        query_params = {
+            k: v
+            for k, v in [
+                ("token", token),
+                ("user", user),
+                ("full", full),
+                ("count", count),
+                ("page", page),
+                ("cursor", cursor),
+                ("limit", limit),
+            ]
+            if v is not None
+        }
+        response = self._get(url, params=query_params)
+        return self._handle_response(response)
+
+    def search_messages(
+        self,
+        token: str,
+        query: str,
+        count: int | None = None,
+        highlight: bool | None = None,
+        page: int | None = None,
+        sort: str | None = None,
+        sort_dir: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Searches for and retrieves Slack messages matching a specified query, with options for pagination, sorting, and query highlighting[1][2].
+
+        Args:
+            token (string): A required string parameter named "token" passed as a query parameter to authenticate the request for retrieving search messages.
+            query (string): The search query string to specify the text or keywords to search for in messages.
+            count (integer): Optional integer parameter "count" specifying the number of search messages to return, defaulting to 1 if not provided.
+            highlight (boolean): Indicates whether to highlight specific parts of the search results in the messages.
+            page (integer): The page query parameter specifies the page number of search results to retrieve in the GET /search.messages operation.
+            sort (string): Sorts the search results by a specified field, allowing clients to customize the order of returned messages.
+            sort_dir (string): The "sort_dir" query parameter specifies the direction of sorting for the search results, typically accepting values like "asc" for ascending or "desc" for descending order.
+
+        Returns:
+            dict[str, Any]: Typical success response
+
+        Raises:
+            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+
+        Tags:
+            search
+        """
+        url = f"{self.base_url}/search.messages"
+        query_params = {
+            k: v
+            for k, v in [
+                ("token", token),
+                ("count", count),
+                ("highlight", highlight),
+                ("page", page),
+                ("query", query),
+                ("sort", sort),
+                ("sort_dir", sort_dir),
+            ]
+            if v is not None
+        }
+        response = self._get(url, params=query_params)
+        return self._handle_response(response)
+
+    def team_info(self, token: str, team: str | None = None) -> dict[str, Any]:
+        """
+        Retrieves information about a Slack team, including its custom icon and basic details, using a provided authentication token[1][3][4].
+
+        Args:
+            token (string): Mandatory authentication token passed as a query parameter to authenticate the request for retrieving team information.
+            team (string): The "team" parameter is a query string parameter of type string, used to specify the team for which information is requested in the GET operation at the "/team.info" path.
+
+        Returns:
+            dict[str, Any]: Typical success response
+
+        Raises:
+            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+
+        Tags:
+            team
+        """
+        url = f"{self.base_url}/team.info"
+        query_params = {
+            k: v for k, v in [("token", token), ("team", team)] if v is not None
+        }
+        response = self._get(url, params=query_params)
+        return self._handle_response(response)
+
+    def users_info(
+        self,
+        token: str,
+        include_locale: bool | None = None,
+        user: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Retrieves information about a specific Slack workspace member using the `users.info` method, returning a user object that includes profile details such as name and display name.
+
+        Args:
+            token (string): The token query parameter is a required string used to authenticate and authorize the API request to access user information in the GET /users.info operation.
+            include_locale (boolean): Indicates whether to include locale information in the response, with a value of true or false.
+            user (string): A string parameter used to identify or specify a user in the request.
+
+        Returns:
+            dict[str, Any]: Typical success response
+
+        Raises:
+            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+
+        Tags:
+            users
+        """
+        url = f"{self.base_url}/users.info"
+        query_params = {
+            k: v
+            for k, v in [
+                ("token", token),
+                ("include_locale", include_locale),
+                ("user", user),
+            ]
+            if v is not None
+        }
+        response = self._get(url, params=query_params)
+        return self._handle_response(response)
+
+    def users_list(
+        self,
+        token: str | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+        include_locale: bool | None = None,
+    ) -> dict[str, Any]:
+        """
+        Retrieves a list of all users in a Slack workspace, using the "GET" method, including both invited and deactivated users, with optional parameters for limiting results and pagination.
+
+        Args:
+            token (string): Required authentication token for accessing the list of users.
+            limit (integer): Specifies the maximum number of users to return in the response, defaults to 1.
+            cursor (string): A unique string identifier used for cursor-based pagination, indicating the starting point for retrieving the next set of users in the list.
+            include_locale (boolean): A boolean query parameter to optionally include locale information in the response.
+
+        Returns:
+            dict[str, Any]: Typical success response
+
+        Raises:
+            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+
+        Tags:
+            users
+        """
+        url = f"{self.base_url}/users.list"
+        query_params = {
+            k: v
+            for k, v in [
+                ("token", token),
+                ("limit", limit),
+                ("cursor", cursor),
+                ("include_locale", include_locale),
+            ]
+            if v is not None
+        }
+        response = self._get(url, params=query_params)
+        return self._handle_response(response)
+
+    def list_tools(self):
+        return [
+            self.chat_delete,
+            self.chat_post_message,
+            self.chat_update,
+            self.conversations_history,
+            self.conversations_list,
+            self.reactions_add,
+            self.reactions_get,
+            self.reactions_list,
+            self.search_messages,
+            self.team_info,
+            self.users_info,
+            self.users_list,
+        ]

universal_mcp/applications/spotify/README.md

@@ -0,0 +1,91 @@
+# Spotify MCP Server
+
+An MCP Server for the Spotify API.
+
+## 🛠️ Tool List
+
+This is automatically generated from OpenAPI schema for the Spotify API.
+
+
+| Tool | Description |
+|------|-------------|
+| `get_an_album` | Retrieves detailed information about a specific album by its ID from the API. |
+| `get_multiple_albums` | Retrieves detailed information for multiple albums by their IDs from the API. |
+| `get_an_albums_tracks` | Retrieves the list of tracks for a specified album from the API, with optional filtering and pagination. |
+| `get_an_artist` | Retrieve detailed information about a specific artist by their unique identifier. |
+| `get_multiple_artists` | Retrieves information for multiple artists using their IDs. |
+| `get_an_artists_albums` | Retrieves a list of albums for the specified artist from the API. |
+| `get_an_artists_top_tracks` | Retrieves the top tracks for a specified artist from the API. |
+| `get_an_artists_related_artists` | Retrieves a list of artists related to the specified artist by their unique ID. |
+| `get_a_show` | Retrieve detailed information about a show by its unique identifier. |
+| `get_multiple_shows` | Retrieves information for multiple shows by their IDs, with optional market filtering. |
+| `get_a_shows_episodes` | Retrieves episodes for a specific show from the API with optional market, limit, and offset parameters. |
+| `get_an_episode` | Retrieves a single podcast episode's details by its unique identifier. |
+| `get_multiple_episodes` | Retrieves details for multiple podcast episodes using their IDs, optionally filtered by market. |
+| `get_an_audiobook` | Retrieves detailed information about a specific audiobook by ID, optionally filtered by market. |
+| `get_multiple_audiobooks` | Fetches details for multiple audiobooks by their IDs, optionally filtered by market. |
+| `get_audiobook_chapters` | Retrieves the chapters for a specified audiobook from the API. |
+| `get_users_saved_audiobooks` | Retrieves the current user's saved audiobooks from the API with optional pagination. |
+| `save_audiobooks_user` | Saves one or more audiobooks to the current user's library. |
+| `remove_audiobooks_user` | Removes one or more audiobooks from the authenticated user's library. |
+| `check_users_saved_audiobooks` | Checks if the specified audiobooks are saved in the current user's library. |
+| `get_a_chapter` | Retrieves a specific chapter's details by ID from the API, optionally filtering by market. |
+| `get_several_chapters` | Retrieve details for multiple chapters based on their IDs, optionally filtering by market. |
+| `get_track` | Retrieves detailed information about a track by its unique identifier from the external API. |
+| `get_several_tracks` | Retrieves metadata for multiple tracks based on their IDs from the API. |
+| `search` | Performs a search query against the API and returns the matching results as a JSON object. |
+| `get_current_users_profile` | Retrieves the current authenticated user's profile information from the API. |
+| `get_playlist` | Retrieves a playlist from the API using the specified playlist ID. |
+| `change_playlist_details` | Update the details of an existing playlist with the specified attributes. |
+| `get_playlists_tracks` | Retrieves the tracks of a specified playlist from the API, applying optional filters and pagination parameters. |
+| `add_tracks_to_playlist` | Adds one or more tracks to a specified playlist at an optional position. |
+| `reorder_or_replace_playlists_tracks` | Reorders or replaces tracks in a playlist by moving, inserting, or replacing track entries using the specified parameters. |
+| `get_a_list_of_current_users_playlists` | Retrieves a list of the current user's playlists with optional pagination controls. |
+| `get_users_saved_albums` | Retrieves the current user's saved albums from the Spotify library with optional pagination and market filtering. |
+| `check_users_saved_albums` | Checks if the specified albums are saved in the current user's Spotify library. |
+| `get_users_saved_tracks` | Retrieves the current user's saved tracks from the Spotify library with optional filtering and pagination. |
+| `save_tracks_user` | Saves one or more tracks to the current user's music library. |
+| `check_users_saved_tracks` | Checks if the current user has saved specific tracks in their Spotify library. |
+| `get_users_saved_episodes` | Retrieves the current user's saved podcast episodes from the service, with optional support for market, pagination, and result limits. |
+| `save_episodes_user` | Saves episodes to the user's library using the provided list of episode IDs. |
+| `check_users_saved_episodes` | Checks if the specified episodes are saved in the current user's library. |
+| `get_users_saved_shows` | Retrieves the current user's saved shows from the Spotify API with optional pagination. |
+| `check_users_saved_shows` | Checks if the specified shows are saved in the current user's library. |
+| `get_users_profile` | Retrieves the profile information for a specific user by user ID. |
+| `get_list_users_playlists` | Retrieves a list of playlists for a specified user. |
+| `create_playlist` | Creates a new playlist for a specified user with optional visibility, collaboration, and description settings. |
+| `follow_playlist` | Follows a Spotify playlist on behalf of the current user. |
+| `unfollow_playlist` | Unfollows the specified playlist by deleting the current user's following relationship. |
+| `get_featured_playlists` | Retrieves a list of Spotify's featured playlists with optional localization, result limiting, and pagination. |
+| `get_categories` | Retrieves a list of category objects from the API with optional locale, limit, and offset filters. |
+| `get_a_category` | Retrieve detailed information about a specific category by its ID, optionally localized to a given locale. |
+| `get_a_categories_playlists` | Retrieves playlists associated with a specified category from the API. |
+| `get_playlist_cover` | Retrieves the cover image(s) for a specified playlist by its unique ID. |
+| `get_new_releases` | Retrieves a list of new music releases with optional pagination parameters. |
+| `get_followed` | Retrieves the list of entities the current user is following, with support for pagination and limiting results. |
+| `follow_artists_users` | Follows one or more artists or users on behalf of the current user. |
+| `check_current_user_follows` | Check if the current user follows specific Spotify users or artists. |
+| `check_if_user_follows_playlist` | Checks if one or more users follow a specified playlist. |
+| `get_several_audio_features` | Retrieves audio feature information for multiple tracks using their IDs. |
+| `get_audio_features` | Retrieves audio feature information for a given identifier from the API. |
+| `get_audio_analysis` | Retrieves the audio analysis data for a specified audio ID from the API. |
+| `get_recommendations` | Retrieves track recommendations based on a combination of seed values and audio feature constraints. |
+| `get_recommendation_genres` | Retrieves a list of available genre seeds for recommendations from the remote API. |
+| `get_information_about_the_users_current_playback` | Retrieves information about the user's current playback state from the music service. |
+| `transfer_a_users_playback` | Transfers the playback of a user's current session to one or more specified devices. |
+| `get_a_users_available_devices` | Retrieves the list of devices available to the current user for playback control. |
+| `get_the_users_currently_playing_track` | Retrieves information about the track currently being played by the user. |
+| `start_a_users_playback` | Starts or resumes playback of a user's Spotify player on the specified device, context, or track list. |
+| `pause_a_users_playback` | Pauses the current playback for the authenticated user. |
+| `skip_users_playback_to_next_track` | Skips the user's playback to the next track on the current or specified device. |
+| `skip_users_playback_to_previous_track` | Skips the user's playback to the previous track on the active or specified device. |
+| `seek_to_position_in_currently_playing_track` | Seeks to the specified position in the currently playing track for the user. |
+| `set_repeat_mode_on_users_playback` | Sets the repeat mode for the current user's playback on Spotify, optionally targeting a specific device. |
+| `set_volume_for_users_playback` | Set the playback volume for the current user's active device. |
+| `toggle_shuffle_for_users_playback` | Toggles the shuffle state for the user's playback on the specified device. |
+| `get_recently_played` | Retrieves the current user's recently played tracks from the Spotify API, optionally filtered by time or limited in count. |
+| `get_queue` | Retrieves the current playback queue for the user from the music player API. |
+| `add_to_queue` | Adds an item to the user's playback queue on the specified device using its URI. |
+| `get_available_markets` | Retrieves a list of available markets from the API endpoint. |
+| `get_users_top_artists` | Retrieves the current user's top artists from the API, supporting optional filtering by time range, result limit, and pagination offset. |
+| `get_users_top_tracks` | Retrieves the current user's top tracks from the service within an optional time range, with pagination support. |

universal_mcp/applications/spotify/__init__.py

@@ -0,0 +1 @@
+from .app import SpotifyApp