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

universal_mcp/applications/exa/README.md

@@ -0,0 +1,15 @@
+# Exa MCP Server
+
+An MCP Server for the Exa API.
+
+## 🛠️ Tool List
+
+This is automatically generated from OpenAPI schema for the Exa API.
+
+
+| Tool | Description |
+|------|-------------|
+| `search` | Searches for data using the specified criteria and returns a list of results. |
+| `find_similar` | Finds and returns similar items using the API at "/findSimilar" via the POST method. |
+| `get_contents` | Creates new content entries via a POST request to the "/contents" endpoint. |
+| `answer` | Provides an answer to a query using the API endpoint at "/answer" via the POST method. |

universal_mcp/applications/exa/__init__.py

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

universal_mcp/applications/exa/app.py

@@ -0,0 +1,221 @@
+from typing import Any
+
+from universal_mcp.applications.application import APIApplication
+from universal_mcp.integrations import Integration
+
+
+class ExaApp(APIApplication):
+    def __init__(self, integration: Integration = None, **kwargs) -> None:
+        super().__init__(name="exa", integration=integration, **kwargs)
+        self.base_url = "https://api.exa.ai"
+
+    def search(
+        self,
+        query,
+        useAutoprompt=None,
+        type=None,
+        category=None,
+        numResults=None,
+        includeDomains=None,
+        excludeDomains=None,
+        startCrawlDate=None,
+        endCrawlDate=None,
+        startPublishedDate=None,
+        endPublishedDate=None,
+        includeText=None,
+        excludeText=None,
+        contents=None,
+    ) -> dict[str, Any]:
+        """
+        Searches for data using the specified criteria and returns a list of results.
+
+        Args:
+            query (string): The query string for the search. Example: 'Latest developments in LLM capabilities'.
+            useAutoprompt (boolean): Autoprompt converts your query to an Exa-style query. Enabled by default for auto search, optional for neural search, and not available for keyword search. Example: 'True'.
+            type (string): The type of search. Neural uses an embeddings-based model, keyword is google-like SERP. Default is auto, which automatically decides between keyword and neural. Example: 'auto'.
+            category (string): A data category to focus on. Example: 'research paper'.
+            numResults (integer): Number of results to return (up to thousands of results available for custom plans) Example: '10'.
+            includeDomains (array): List of domains to include in the search. If specified, results will only come from these domains. Example: "['arxiv.org', 'paperswithcode.com']".
+            excludeDomains (array): List of domains to exclude from search results. If specified, no results will be returned from these domains.
+            startCrawlDate (string): Crawl date refers to the date that Exa discovered a link. Results will include links that were crawled after this date. Must be specified in ISO 8601 format. Example: '2023-01-01'.
+            endCrawlDate (string): Crawl date refers to the date that Exa discovered a link. Results will include links that were crawled before this date. Must be specified in ISO 8601 format. Example: '2023-12-31'.
+            startPublishedDate (string): Only links with a published date after this will be returned. Must be specified in ISO 8601 format. Example: '2023-01-01'.
+            endPublishedDate (string): Only links with a published date before this will be returned. Must be specified in ISO 8601 format. Example: '2023-12-31'.
+            includeText (array): List of strings that must be present in webpage text of results. Currently, only 1 string is supported, of up to 5 words. Example: "['large language model']".
+            excludeText (array): List of strings that must not be present in webpage text of results. Currently, only 1 string is supported, of up to 5 words. Example: "['course']".
+            contents (object): contents
+
+        Returns:
+            dict[str, Any]: OK
+
+        Tags:
+            important
+        """
+        request_body = {
+            "query": query,
+            "useAutoprompt": useAutoprompt,
+            "type": type,
+            "category": category,
+            "numResults": numResults,
+            "includeDomains": includeDomains,
+            "excludeDomains": excludeDomains,
+            "startCrawlDate": startCrawlDate,
+            "endCrawlDate": endCrawlDate,
+            "startPublishedDate": startPublishedDate,
+            "endPublishedDate": endPublishedDate,
+            "includeText": includeText,
+            "excludeText": excludeText,
+            "contents": contents,
+        }
+        request_body = {k: v for k, v in request_body.items() if v is not None}
+        url = f"{self.base_url}/search"
+        query_params = {}
+        response = self._post(url, data=request_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def find_similar(
+        self,
+        url,
+        numResults=None,
+        includeDomains=None,
+        excludeDomains=None,
+        startCrawlDate=None,
+        endCrawlDate=None,
+        startPublishedDate=None,
+        endPublishedDate=None,
+        includeText=None,
+        excludeText=None,
+        contents=None,
+    ) -> dict[str, Any]:
+        """
+        Finds and returns similar items using the API at "/findSimilar" via the POST method.
+
+        Args:
+            url (string): The url for which you would like to find similar links. Example: 'https://arxiv.org/abs/2307.06435'.
+            numResults (integer): Number of results to return (up to thousands of results available for custom plans) Example: '10'.
+            includeDomains (array): List of domains to include in the search. If specified, results will only come from these domains. Example: "['arxiv.org', 'paperswithcode.com']".
+            excludeDomains (array): List of domains to exclude from search results. If specified, no results will be returned from these domains.
+            startCrawlDate (string): Crawl date refers to the date that Exa discovered a link. Results will include links that were crawled after this date. Must be specified in ISO 8601 format. Example: '2023-01-01'.
+            endCrawlDate (string): Crawl date refers to the date that Exa discovered a link. Results will include links that were crawled before this date. Must be specified in ISO 8601 format. Example: '2023-12-31'.
+            startPublishedDate (string): Only links with a published date after this will be returned. Must be specified in ISO 8601 format. Example: '2023-01-01'.
+            endPublishedDate (string): Only links with a published date before this will be returned. Must be specified in ISO 8601 format. Example: '2023-12-31'.
+            includeText (array): List of strings that must be present in webpage text of results. Currently, only 1 string is supported, of up to 5 words. Example: "['large language model']".
+            excludeText (array): List of strings that must not be present in webpage text of results. Currently, only 1 string is supported, of up to 5 words. Example: "['course']".
+            contents (object): contents
+
+        Returns:
+            dict[str, Any]: OK
+
+        Tags:
+            important
+        """
+        request_body = {
+            "url": url,
+            "numResults": numResults,
+            "includeDomains": includeDomains,
+            "excludeDomains": excludeDomains,
+            "startCrawlDate": startCrawlDate,
+            "endCrawlDate": endCrawlDate,
+            "startPublishedDate": startPublishedDate,
+            "endPublishedDate": endPublishedDate,
+            "includeText": includeText,
+            "excludeText": excludeText,
+            "contents": contents,
+        }
+        request_body = {k: v for k, v in request_body.items() if v is not None}
+        url = f"{self.base_url}/findSimilar"
+        query_params = {}
+        response = self._post(url, data=request_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def get_contents(
+        self,
+        urls,
+        ids=None,
+        text=None,
+        highlights=None,
+        summary=None,
+        livecrawl=None,
+        livecrawlTimeout=None,
+        subpages=None,
+        subpageTarget=None,
+        extras=None,
+    ) -> dict[str, Any]:
+        """
+        Creates new content entries via a POST request to the "/contents" endpoint.
+
+        Args:
+            urls (array): Array of URLs to crawl (backwards compatible with 'ids' parameter). Example: "['https://arxiv.org/pdf/2307.06435']".
+            ids (array): Deprecated - use 'urls' instead. Array of document IDs obtained from searches. Example: "['https://arxiv.org/pdf/2307.06435']".
+            text (string): text
+            highlights (object): Text snippets the LLM identifies as most relevant from each page.
+            summary (object): Summary of the webpage
+            livecrawl (string): Options for livecrawling pages.
+        'never': Disable livecrawling (default for neural search).
+        'fallback': Livecrawl when cache is empty (default for keyword search).
+        'always': Always livecrawl.
+        'auto': Use an LLM to detect if query needs real-time content.
+         Example: 'always'.
+            livecrawlTimeout (integer): The timeout for livecrawling in milliseconds. Example: '1000'.
+            subpages (integer): The number of subpages to crawl. The actual number crawled may be limited by system constraints. Example: '1'.
+            subpageTarget (string): Keyword to find specific subpages of search results. Can be a single string or an array of strings, comma delimited. Example: 'sources'.
+            extras (object): Extra parameters to pass.
+
+        Returns:
+            dict[str, Any]: OK
+
+        Tags:
+            important
+        """
+        request_body = {
+            "urls": urls,
+            "ids": ids,
+            "text": text,
+            "highlights": highlights,
+            "summary": summary,
+            "livecrawl": livecrawl,
+            "livecrawlTimeout": livecrawlTimeout,
+            "subpages": subpages,
+            "subpageTarget": subpageTarget,
+            "extras": extras,
+        }
+        request_body = {k: v for k, v in request_body.items() if v is not None}
+        url = f"{self.base_url}/contents"
+        query_params = {}
+        response = self._post(url, data=request_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def answer(self, query, stream=None, text=None, model=None) -> dict[str, Any]:
+        """
+        Provides an answer to a query using the API endpoint at "/answer" via the POST method.
+
+        Args:
+            query (string): The question or query to answer. Example: 'What is the latest valuation of SpaceX?'.
+            stream (boolean): If true, the response is returned as a server-sent events (SSS) stream.
+            text (boolean): If true, the response includes full text content in the search results
+            model (string): The search model to use for the answer. Exa passes only one query to exa, while exa-pro also passes 2 expanded queries to our search model.
+
+        Returns:
+            dict[str, Any]: OK
+
+        Tags:
+            important
+        """
+        request_body = {
+            "query": query,
+            "stream": stream,
+            "text": text,
+            "model": model,
+        }
+        request_body = {k: v for k, v in request_body.items() if v is not None}
+        url = f"{self.base_url}/answer"
+        query_params = {}
+        response = self._post(url, data=request_body, params=query_params)
+        response.raise_for_status()
+        return response.json()
+
+    def list_tools(self):
+        return [self.search, self.find_similar, self.get_contents, self.answer]

universal_mcp/applications/falai/README.md

@@ -0,0 +1,17 @@
+# Falai MCP Server
+
+An MCP Server for the Falai API.
+
+## 🛠️ Tool List
+
+This is automatically generated from OpenAPI schema for the Falai API.
+
+| Tool             | Description                                                                                                                                                  |
+| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `run`            | Run a Fal AI application directly and wait for the result. Suitable for short-running applications with synchronous execution from the caller's perspective. |
+| `submit`         | Submits a request to the Fal AI queue for asynchronous processing and returns a request ID for tracking the job.                                             |
+| `status`         | Checks the status of a previously submitted Fal AI request and retrieves its current execution state                                                         |
+| `result`         | Retrieves the result of a completed Fal AI request, waiting for completion if the request is still running.                                                  |
+| `cancel`         | Asynchronously cancels a running or queued Fal AI request.                                                                                                   |
+| `upload_file`    | Uploads a local file to the Fal CDN and returns its public URL                                                                                               |
+| `generate_image` | Asynchronously generates images using the 'fal-ai/flux/dev' application with customizable parameters and default settings                                    |

universal_mcp/applications/falai/__init__.py

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

universal_mcp/applications/falai/app.py

@@ -0,0 +1,331 @@
+from pathlib import Path
+from typing import Any, Literal
+
+from fal_client import AsyncClient, AsyncRequestHandle, Status
+from loguru import logger
+from universal_mcp.applications.application import APIApplication
+from universal_mcp.exceptions import NotAuthorizedError, ToolError
+from universal_mcp.integrations import Integration
+
+Priority = Literal["normal", "low"]
+
+
+class FalaiApp(APIApplication):
+    """
+    Application for interacting with the Fal AI platform.
+
+    Provides tools to run, submit, check status, retrieve results, cancel jobs,
+    upload files to the Fal CDN, and a specialized tool for generating images.
+
+    Authentication is handled by the configured Integration provided by the
+    Universal MCP server, fetching the necessary API key.
+    """
+
+    def __init__(self, integration: Integration, **kwargs) -> None:
+        super().__init__(name="falai", integration=integration, **kwargs)
+        self._fal_client = None
+
+    @property
+    def fal_client(self) -> AsyncClient:
+        if self._fal_client is None:
+            credentials = self.integration.get_credentials()
+            logger.info(f"Credentials: {credentials}")
+            api_key = (
+                credentials.get("api_key")
+                or credentials.get("API_KEY")
+                or credentials.get("apiKey")
+            )
+            if not api_key:
+                logger.error(
+                    f"Integration {type(self.integration).__name__} returned credentials in unexpected format."
+                )
+                raise NotAuthorizedError(
+                    "Integration returned empty or invalid API key."
+                )
+            self._fal_client = AsyncClient(key=api_key)
+        return self._fal_client
+
+    async def run(
+        self,
+        arguments: Any,
+        application: str = "fal-ai/flux/dev",
+        path: str = "",
+        timeout: float | None = None,
+        hint: str | None = None,
+    ) -> Any:
+        """
+        Run a Fal AI application directly and wait for the result. Suitable for short-running applications with synchronous execution from the caller's perspective.
+
+        Args:
+            arguments: A dictionary of arguments for the application
+            application: The name or ID of the Fal application (defaults to 'fal-ai/flux/dev')
+            path: Optional subpath for the application endpoint
+            timeout: Optional timeout in seconds for the request
+            hint: Optional hint for runner selection
+
+        Returns:
+            The result of the application execution as a Python object (converted from JSON response)
+
+        Raises:
+            ToolError: Raised when the Fal API request fails, wrapping the original exception
+
+        Tags:
+            run, execute, ai, synchronous, fal, important
+        """
+        try:
+            result = await self.fal_client.run(
+                application=application,
+                arguments=arguments,
+                path=path,
+                timeout=timeout,
+                hint=hint,
+            )
+            return result
+        except Exception as e:
+            logger.error(
+                f"Error running Fal application {application}: {e}", exc_info=True
+            )
+            raise ToolError(f"Failed to run Fal application {application}: {e}") from e
+
+    async def submit(
+        self,
+        arguments: Any,
+        application: str = "fal-ai/flux/dev",
+        path: str = "",
+        hint: str | None = None,
+        webhook_url: str | None = None,
+        priority: Priority | None = None,
+    ) -> str:
+        """
+        Submits a request to the Fal AI queue for asynchronous processing and returns a request ID for tracking the job.
+
+        Args:
+            arguments: A dictionary of arguments for the application
+            application: The name or ID of the Fal application, defaulting to 'fal-ai/flux/dev'
+            path: Optional subpath for the application endpoint
+            hint: Optional hint for runner selection
+            webhook_url: Optional URL to receive a webhook when the request completes
+            priority: Optional queue priority ('normal' or 'low')
+
+        Returns:
+            The request ID (str) of the submitted asynchronous job
+
+        Raises:
+            ToolError: Raised when the Fal API request fails, wrapping the original exception
+
+        Tags:
+            submit, async_job, start, ai, queue
+        """
+        try:
+            handle: AsyncRequestHandle = await self.fal_client.submit(
+                application=application,
+                arguments=arguments,
+                path=path,
+                hint=hint,
+                webhook_url=webhook_url,
+                priority=priority,
+            )
+            request_id = handle.request_id
+            return request_id
+        except Exception as e:
+            logger.error(
+                f"Error submitting Fal application {application}: {e}", exc_info=True
+            )
+            raise ToolError(
+                f"Failed to submit Fal application {application}: {e}"
+            ) from e
+
+    async def status(
+        self,
+        request_id: str,
+        application: str = "fal-ai/flux/dev",
+        with_logs: bool = False,
+    ) -> Status:
+        """
+        Checks the status of a previously submitted Fal AI request and retrieves its current execution state
+
+        Args:
+            request_id: The unique identifier of the submitted request, obtained from a previous submit operation
+            application: The name or ID of the Fal application (defaults to 'fal-ai/flux/dev')
+            with_logs: Boolean flag to include execution logs in the status response (defaults to False)
+
+        Returns:
+            A Status object containing the current state of the request (Queued, InProgress, or Completed)
+
+        Raises:
+            ToolError: Raised when the Fal API request fails or when the provided request ID is invalid
+
+        Tags:
+            status, check, async_job, monitoring, ai
+        """
+        try:
+            handle = self.fal_client.get_handle(
+                application=application, request_id=request_id
+            )
+            status = await handle.status(with_logs=with_logs)
+            return status
+        except Exception as e:
+            logger.error(
+                f"Error getting status for Fal request_id {request_id}: {e}",
+                exc_info=True,
+            )
+            raise ToolError(
+                f"Failed to get status for Fal request_id {request_id}: {e}"
+            ) from e
+
+    async def result(
+        self, request_id: str, application: str = "fal-ai/flux/dev"
+    ) -> Any:
+        """
+        Retrieves the result of a completed Fal AI request, waiting for completion if the request is still running.
+
+        Args:
+            request_id: The unique identifier of the submitted request
+            application: The name or ID of the Fal application (defaults to 'fal-ai/flux/dev')
+
+        Returns:
+            The result of the application execution, converted from JSON response to Python data structures (dict/list)
+
+        Raises:
+            ToolError: When the Fal API request fails or the request does not complete successfully
+
+        Tags:
+            result, async-job, status, wait, ai
+        """
+        try:
+            handle = self.fal_client.get_handle(
+                application=application, request_id=request_id
+            )
+            result = await handle.get()
+            return result
+        except Exception as e:
+            logger.error(
+                f"Error getting result for Fal request_id {request_id}: {e}",
+                exc_info=True,
+            )
+            raise ToolError(
+                f"Failed to get result for Fal request_id {request_id}: {e}"
+            ) from e
+
+    async def cancel(
+        self, request_id: str, application: str = "fal-ai/flux/dev"
+    ) -> None:
+        """
+        Asynchronously cancels a running or queued Fal AI request.
+
+        Args:
+            request_id: The unique identifier of the submitted Fal AI request to cancel
+            application: The name or ID of the Fal application (defaults to 'fal-ai/flux/dev')
+
+        Returns:
+            None. The function doesn't return any value.
+
+        Raises:
+            ToolError: Raised when the cancellation request fails due to API errors or if the request cannot be cancelled
+
+        Tags:
+            cancel, async_job, ai, fal, management
+        """
+        try:
+            handle = self.fal_client.get_handle(
+                application=application, request_id=request_id
+            )
+            await handle.cancel()
+            return None
+        except Exception as e:
+            logger.error(
+                f"Error cancelling Fal request_id {request_id}: {e}", exc_info=True
+            )
+            raise ToolError(f"Failed to cancel Fal request_id {request_id}: {e}") from e
+
+    async def upload_file(self, path: str) -> str:
+        """
+        Uploads a local file to the Fal CDN and returns its public URL
+
+        Args:
+            path: The absolute or relative path to the local file
+
+        Returns:
+            A string containing the public URL of the uploaded file on the CDN
+
+        Raises:
+            ToolError: If the file is not found or if the upload operation fails
+
+        Tags:
+            upload, file, cdn, storage, async, important
+        """
+        try:
+            file_url = await self.fal_client.upload_file(Path(path))
+            return file_url
+        except FileNotFoundError as e:
+            logger.error(f"File not found for upload: {path}", exc_info=True)
+            raise ToolError(f"File not found: {path}") from e
+        except Exception as e:
+            logger.error(f"Error uploading file {path} to Fal CDN: {e}", exc_info=True)
+            raise ToolError(f"Failed to upload file {path}: {e}") from e
+
+    async def generate_image(
+        self,
+        prompt: str,
+        seed: int | None = 6252023,
+        image_size: str | None = "landscape_4_3",
+        num_images: int | None = 1,
+        extra_arguments: dict[str, Any] | None = None,
+        path: str = "",
+        timeout: float | None = None,
+        hint: str | None = None,
+    ) -> Any:
+        """
+        Asynchronously generates images using the 'fal-ai/flux/dev' application with customizable parameters and default settings
+
+        Args:
+            prompt: The text prompt used to guide the image generation
+            seed: Random seed for reproducible image generation (default: 6252023)
+            image_size: Dimensions of the generated image (default: 'landscape_4_3')
+            num_images: Number of images to generate in one request (default: 1)
+            extra_arguments: Additional arguments dictionary to pass to the application, can override defaults
+            path: Subpath for the application endpoint (rarely used)
+            timeout: Maximum time in seconds to wait for the request to complete
+            hint: Hint string for runner selection
+
+        Returns:
+            A dictionary containing the generated image URLs and related metadata
+
+        Raises:
+            ToolError: When the image generation request fails or encounters an error
+
+        Tags:
+            generate, image, ai, async, important, flux, customizable, default
+        """
+        application = "fal-ai/flux/dev"
+        arguments = {
+            "prompt": prompt,
+            "seed": seed,
+            "image_size": image_size,
+            "num_images": num_images,
+        }
+        if extra_arguments:
+            arguments.update(extra_arguments)
+            logger.debug(f"Merged extra_arguments. Final arguments: {arguments}")
+        try:
+            result = await self.run(
+                application=application,
+                arguments=arguments,
+                path=path,
+                timeout=timeout,
+                hint=hint,
+            )
+            return result
+        except Exception:
+            raise
+
+    def list_tools(self) -> list[callable]:
+        return [
+            self.run,
+            self.submit,
+            self.status,
+            self.result,
+            self.cancel,
+            self.upload_file,
+            self.generate_image,
+        ]

universal_mcp/applications/figma/README.md

@@ -0,0 +1,49 @@
+# Figma MCP Server
+
+An MCP Server for the Figma API.
+
+## 🛠️ Tool List
+
+This is automatically generated from OpenAPI schema for the Figma API.
+
+
+| Tool | Description |
+|------|-------------|
+| `get_file` | Retrieves a specified file's data (including versions, geometry, and plugin information) from the API using a unique file identifier. |
+| `get_file_nodes` | Retrieves nodes related to a file identified by the "file_key" using the specified query parameters for filtering by "ids", "version", "depth", "geometry", and "plugin_data". |
+| `get_images` | Retrieves an image specified by the `file_key` using the GET method, allowing optional query parameters for customization such as formatting, scaling, and SVG options. |
+| `get_image_fills` | Retrieves images associated with a file identified by the `{file_key}` using the `/v1/files/{file_key}/images` API endpoint. |
+| `get_team_projects` | Retrieves a list of projects associated with a specific team identified by the team_id parameter. |
+| `get_project_files` | Retrieves files from a specified project, optionally including branch data, using the provided project identifier. |
+| `get_file_versions` | Retrieves a list of file versions using the "GET" method, filtering by file key and optional query parameters for pagination and sorting. |
+| `get_comments` | Retrieves comments associated with a specified file and optionally returns them in Markdown format based on the query parameter. |
+| `post_comment` | Creates a new comment on a file specified by the file_key and returns an appropriate status code. |
+| `delete_comment` | Deletes a specified comment from a file identified by its file key and comment ID. |
+| `get_comment_reactions` | Retrieves reactions for a specific comment in a file using the provided file key and comment ID. |
+| `post_comment_reaction` | Adds a reaction to a specific comment on a file identified by the file key and comment ID using the "POST" method at the "/v1/files/{file_key}/comments/{comment_id}/reactions" endpoint. |
+| `delete_comment_reaction` | Removes a reaction emoji from a comment on a file using the specified emoji parameter. |
+| `get_me` | Retrieves the authenticated user's profile data. |
+| `get_team_components` | Retrieves a list of components for a specified team with pagination support using page_size, after, and before parameters. |
+| `get_file_components` | Retrieves a list of components associated with a file identified by the specified file key using the API endpoint "/v1/files/{file_key}/components". |
+| `get_component` | Retrieves component information for a specific key using the API endpoint at "/v1/components/{key}" with the GET method. |
+| `get_team_component_sets` | Retrieves a paginated list of component sets associated with a specific team ID, supporting pagination via page size, after, and before query parameters. |
+| `get_file_component_sets` | Retrieves the component sets associated with a file identified by a specific file key using the "GET" method at the "/v1/files/{file_key}/component_sets" endpoint. |
+| `get_component_set` | Retrieves a component set by its unique key identifier and returns the associated component data. |
+| `get_team_styles` | Retrieves paginated style resources associated with a specific team using query parameters for pagination control. |
+| `get_file_styles` | Retrieves styles information for a specific file identified by the file key using the API endpoint "/v1/files/{file_key}/styles" with the GET method. |
+| `get_style` | Retrieves a style object associated with the specified key using the "GET" method at the "/v1/styles/{key}" endpoint. |
+| `post_webhook` | Registers a new webhook to receive HTTP callbacks for specified events, returning success or error status codes. |
+| `get_webhook` | Retrieves information about a specific webhook by its ID using the "GET" method at the path "/v2/webhooks/{webhook_id}". |
+| `put_webhook` | Updates an existing webhook's configuration using the provided webhook ID and returns an HTTP status code indicating success or failure. |
+| `delete_webhook` | Deletes a webhook identified by its `webhook_id`, permanently removing it to manage and optimize webhook configurations. |
+| `get_team_webhooks` | Retrieves a list of webhooks for a specified team using the "GET" method, with the team identified by the `team_id` path parameter. |
+| `get_webhook_requests` | Retrieves a list of requests for a specific webhook identified by `{webhook_id}` using the "GET" method. |
+| `get_activity_logs` | Retrieves a list of activity logs filtered by specified events, time range, and other parameters, returning the results in a specified order with a limited number of entries. |
+| `get_payments` | Retrieves payment information based on specified parameters, including plugin payment token, user ID, community file ID, plugin ID, and widget ID, using the "/v1/payments" API endpoint with a GET request. |
+| `get_local_variables` | Retrieves local variables for a file specified by the "file_key" using the "GET" method. |
+| `get_published_variables` | Retrieves the published variables for a file identified by the `{file_key}` using the `GET` method. |
+| `post_variables` | Creates variables for a specific file identified by its file_key and returns an appropriate status code based on the operation's outcome. |
+| `get_dev_resources` | Retrieves development resources associated with a specific file, identified by its file_key, with optional filtering by node IDs. |
+| `post_dev_resources` | Creates developer resources via the API and returns a status response. |
+| `put_dev_resources` | Replaces a specific developer resource at the specified path with updated data, returning a status code for success or error conditions. |
+| `delete_dev_resource` | Deletes a specific development resource associated with a file using the provided file key and development resource ID. |

universal_mcp/applications/figma/__init__.py

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