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

universal_mcp/applications/firecrawl/app.py

@@ -27,8 +27,7 @@ class FirecrawlApp(APIApplication):
         if FirecrawlApiClient is None:
             logger.warning("Firecrawl SDK is not available. Firecrawl tools will not function.")
 
-    @property
-    def firecrawl_api_key(self) -> str:
+    async def get_firecrawl_api_key(self) -> str:
         """
         A property that lazily retrieves and caches the Firecrawl API key from the configured integration. On first access, it fetches credentials and raises a `NotAuthorizedError` if the key is unobtainable, ensuring all subsequent API calls within the application are properly authenticated before execution.
         """
@@ -37,7 +36,7 @@ class FirecrawlApp(APIApplication):
                 logger.error(f"{self.name.capitalize()} App: Integration not configured.")
                 raise NotAuthorizedError(f"Integration not configured for {self.name.capitalize()} App. Cannot retrieve API key.")
             try:
-                credentials = self.integration.get_credentials()
+                credentials = await self.integration.get_credentials_async()
             except NotAuthorizedError as e:
                 logger.error(f"{self.name.capitalize()} App: Authorization error when fetching credentials: {e.message}")
                 raise
@@ -65,7 +64,7 @@ class FirecrawlApp(APIApplication):
         assert self._firecrawl_api_key is not None
         return self._firecrawl_api_key
 
-    def _get_client(self) -> AsyncFirecrawl:
+    async def get_firecrawl_client(self) -> AsyncFirecrawl:
         """
         Initializes and returns the Firecrawl client after ensuring API key is set.
         Raises NotAuthorizedError if API key cannot be obtained or SDK is not installed.
@@ -73,7 +72,7 @@ class FirecrawlApp(APIApplication):
         if FirecrawlApiClient is None:
             logger.error("Firecrawl SDK (firecrawl-py) is not available.")
             raise ToolError("Firecrawl SDK (firecrawl-py) is not installed or failed to import.")
-        current_api_key = self.firecrawl_api_key
+        current_api_key = await self.get_firecrawl_api_key()
         return FirecrawlApiClient(api_key=current_api_key)
 
     def _handle_firecrawl_exception(self, e: Exception, operation_desc: str) -> str:
@@ -161,7 +160,7 @@ class FirecrawlApp(APIApplication):
         """
         logger.info(f"Attempting to scrape URL: {url} with schema: {schema is not None}, prompt: {prompt is not None}")
         try:
-            client = self._get_client()
+            client = await self.get_firecrawl_client()
             
             # Construct formats if schema or prompt is provided (V2 structured output)
             if schema or prompt:
@@ -212,7 +211,7 @@ class FirecrawlApp(APIApplication):
         """
         logger.info(f"Attempting Firecrawl search for query: {query}")
         try:
-            client = self._get_client()
+            client = await self.get_firecrawl_client()
             response = await client.search(query=query)
             logger.info(f"Successfully performed Firecrawl search for query: {query}")
             return self._to_serializable(response)
@@ -250,7 +249,7 @@ class FirecrawlApp(APIApplication):
         """
         logger.info(f"Attempting to start Firecrawl crawl for URL: {url} with limit: {limit}")
         try:
-            client = self._get_client()
+            client = await self.get_firecrawl_client()
             response = await client.start_crawl(url=url, limit=limit, scrape_options=scrape_options)
             job_id = response.id
             logger.info(f"Successfully started Firecrawl crawl for URL {url}, Job ID: {job_id}")
@@ -282,7 +281,7 @@ class FirecrawlApp(APIApplication):
         """
         logger.info(f"Attempting to check Firecrawl crawl status for job ID: {job_id}")
         try:
-            client = self._get_client()
+            client = await self.get_firecrawl_client()
             status = await client.get_crawl_status(job_id=job_id)
             logger.info(f"Successfully checked Firecrawl crawl status for job ID: {job_id}")
             return self._to_serializable(status)
@@ -314,7 +313,7 @@ class FirecrawlApp(APIApplication):
         """
         logger.info(f"Attempting to cancel Firecrawl crawl job ID: {job_id}")
         try:
-            client = self._get_client()
+            client = await self.get_firecrawl_client()
             response = await client.cancel_crawl(crawl_id=job_id)
             logger.info(f"Successfully issued cancel command for Firecrawl crawl job ID: {job_id}")
             return self._to_serializable(response)
@@ -345,7 +344,7 @@ class FirecrawlApp(APIApplication):
         """
         logger.info(f"Attempting to start Firecrawl batch scrape for {len(urls)} URLs.")
         try:
-            client = self._get_client()
+            client = await self.get_firecrawl_client()
             response = await client.start_batch_scrape(urls=urls)
             logger.info(f"Successfully started Firecrawl batch scrape for {len(urls)} URLs.")
             return self._to_serializable(response)
@@ -376,7 +375,7 @@ class FirecrawlApp(APIApplication):
         """
         logger.info(f"Attempting to check Firecrawl batch scrape status for job ID: {job_id}")
         try:
-            client = self._get_client()
+            client = await self.get_firecrawl_client()
             status = await client.get_batch_scrape_status(job_id=job_id)
             logger.info(f"Successfully checked Firecrawl batch scrape status for job ID: {job_id}")
             return self._to_serializable(status)
@@ -448,7 +447,7 @@ class FirecrawlApp(APIApplication):
             f"Attempting quick web extraction for {len(urls)} URLs with prompt: {prompt is not None}, schema: {schema is not None}."
         )
         try:
-            client = self._get_client()
+            client = await self.get_firecrawl_client()
             response = await client.extract(
                 urls=urls, prompt=prompt, schema=schema, system_prompt=system_prompt, allow_external_links=allow_external_links
             )
@@ -488,7 +487,7 @@ class FirecrawlApp(APIApplication):
         """
         logger.info(f"Attempting to check Firecrawl extraction status for job ID: {job_id}")
         try:
-            client = self._get_client()
+            client = await self.get_firecrawl_client()
             status = await client.get_extract_status(job_id=job_id)
             logger.info(f"Successfully checked Firecrawl extraction status for job ID: {job_id}")
             return self._to_serializable(status)
@@ -520,7 +519,7 @@ class FirecrawlApp(APIApplication):
         """
         logger.info(f"Attempting to map site: {url} with limit: {limit}")
         try:
-            client = self._get_client()
+            client = await self.get_firecrawl_client()
             # client.map signature (async): (url, search=None, ignoreSitemap=None, includeSubdomains=None, limit=None)
             # We expose url and limit for now, maybe more if needed later.
             response = await client.map(url=url, limit=limit)

universal_mcp/applications/ghost_content/app.py

@@ -21,7 +21,7 @@ class GhostContentApp(APIApplication):
                          and Content API key.
                          It is expected that the integration provides 'url' (e.g.,
                          "https://your-ghost-site.com") and 'key' (the Content API key)
-                         via `integration.get_credentials()`.
+                         via `integration.get_credentials_async()`.
         """
         super().__init__(name="ghost_content", integration=integration)
         self._base_url = None
@@ -35,7 +35,7 @@ class GhostContentApp(APIApplication):
         This is constructed from the integration's credentials.
         """
         if not self._base_url:
-            credentials = self.integration.get_credentials()
+            credentials = await self.integration.get_credentials_async()
             ghost_url = credentials.get("url") or credentials.get("admin_domain")
             if not ghost_url:
                 logger.error("GhostContentApp: Missing 'url' or 'admin_domain' in integration credentials.")
@@ -63,7 +63,7 @@ class GhostContentApp(APIApplication):
         Caches the key after the first retrieval.
         """
         if not self._api_key:
-            credentials = self.integration.get_credentials()
+            credentials = await self.integration.get_credentials_async()
             api_key = credentials.get("key") or credentials.get("api_key") or credentials.get("API_KEY")
             if not api_key:
                 logger.error("GhostContentApp: Content API key ('key') not found in integration credentials.")
@@ -78,7 +78,7 @@ class GhostContentApp(APIApplication):
         Caches the version after the first retrieval.
         """
         if not self._version:
-            credentials = self.integration.get_credentials()
+            credentials = await self.integration.get_credentials_async()
             version = credentials.get("api_version")
             if not version:
                 logger.warning("GhostContentApp: 'version' not found in integration credentials. Defaulting to 'v5.0'.")

universal_mcp/applications/github/app.py

@@ -10,10 +10,10 @@ class GithubApp(APIApplication):
         self.base_api_url = "https://api.github.com/repos"
         self.base_url = "https://api.github.com"
 
-    def _get_headers(self):
+    async def _aget_headers(self):
         if not self.integration:
             raise ValueError("Integration not configured")
-        credentials = self.integration.get_credentials()
+        credentials = await self.integration.get_credentials_async()
         if "headers" in credentials:
             return credentials["headers"]
         return {"Authorization": f"Bearer {credentials['access_token']}", "Accept": "application/vnd.github.v3+json"}

universal_mcp/applications/gong/app.py

@@ -9,8 +9,8 @@ class GongApp(APIApplication):
         super().__init__(name="gong", integration=integration, **kwargs)
         self.base_url = "https://api.gong.io"
 
-    def _get_headers(self) -> dict[str, str]:
-        credentials = self.integration.get_credentials()
+    async def _aget_headers(self) -> dict[str, str]:
+        credentials = await self.integration.get_credentials_async()
         api_key = credentials.get("api_key")
         secret = credentials.get("secret")
         api_key_b64 = b64encode(f"{api_key}:{secret}".encode()).decode()

universal_mcp/applications/google_docs/README.md

@@ -9,17 +9,18 @@ This is automatically generated from OpenAPI schema for the GoogleDocsApp API.
 
 | Tool | Description |
 |------|-------------|
-| `create_document` | Creates a blank Google Document with a specified title using a POST request to the Google Docs API. This is the primary creation method, returning the document's metadata, including the ID required by functions like `get_document` or `insert_text` to perform subsequent operations on the new file. |
-| `get_document` | Retrieves the complete content and metadata for a specific Google Document using its unique ID. This function performs a GET request to the API, returning the full JSON response. It's the primary read operation, contrasting with `create_document` which creates new documents. |
-| `insert_text` | Inserts a text string at a specified index within an existing Google Document using the `batchUpdate` API. This function adds new textual content, distinguishing it from functions that insert non-text elements like tables or apply formatting (`apply_text_style`) to existing content. |
-| `apply_text_style` | Applies character-level formatting such as bold, italic, font size, color, and hyperlinks to a specified text range in a document. This function modifies text appearance, distinguishing it from `update_paragraph_style`, which handles block-level formatting like alignment and headings. |
-| `delete_content_range` | Deletes content within a specified index range in a Google Document via the batchUpdate API. It removes any content based on location, distinguishing it from functions like `delete_header` or `delete_paragraph_bullets`, which remove specific structures or styles instead. |
-| `insert_table` | Inserts a table with specified row and column dimensions at a given index in a Google Document. This function uses the `batchUpdate` API for precise placement, allowing the table to be added to the document's body, a header, or a footer, returning the API's response. |
-| `create_footer` | Creates a footer of a specified type in a Google Document via the batch update API. The footer can optionally be associated with a specific section break, enabling distinct footers for different document sections, distinguishing it from the `create_header` and `create_footnote` functions. |
-| `create_footnote` | Creates a footnote via the batch update API, inserting a numbered reference at a specified index or a segment's end. This function adds an in-body citation, distinguishing it from `create_footer` which creates a content block at the bottom of the page. |
-| `delete_footer` | Deletes a specific footer from a Google Document using its unique ID via a `batchUpdate` request. This operation, the counterpart to `create_footer`, removes an entire footer section, unlike `delete_content_range` which targets text within a specified index range. |
-| `create_header` | Creates a header in a specified Google Document via the batchUpdate API endpoint. This function allows defining the header type and can optionally associate it with a specific section break location. It complements the `delete_header` and `create_footer` functions for managing document structure. |
-| `delete_header` | Removes a specific header from a Google Document using its unique ID. This function sends a `deleteHeader` request to the batch update API, acting as the direct counterpart to `create_header` and distinguishing it from `delete_footer` which removes footers. |
-| `apply_list_style` | Applies a predefined bulleted or numbered list format to paragraphs within a specified range using a `bullet_preset`. This function adds list formatting, distinguishing it from its counterpart, `delete_paragraph_bullets`, and other styling functions like `update_paragraph_style`, which handles alignment and headings. |
-| `delete_paragraph_bullets` | Removes bullet points or numbering from paragraphs within a specified range in a Google Document. This function reverts list formatting via the batch update API, acting as the direct counterpart to `apply_list_style` and preserving the underlying text content, unlike `delete_content_range`. |
-| `update_paragraph_style` | Applies paragraph-level formatting, such as named styles (e.g., 'HEADING_1'), alignment, or text direction, to a specified text range. This function handles block-level styles, distinguishing it from `apply_text_style`, which formats individual characters with attributes like bold or italic. |
+| `create_document` | 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. |
+| `get_document` | Retrieves the complete, raw JSON object for a Google Document by its ID. This function returns the full, unprocessed API response with all metadata and structural elements, distinguishing it from `get_document_content`, which parses this data to extract only the title and plain text. |
+| `get_document_content` | Retrieves and converts a Google Docs document into Markdown-formatted content. |
+| `insert_text` | Inserts a text string at a specified index within a Google Document using the batchUpdate API. Unlike functions that format existing text or delete content ranges, this method specifically adds new textual content to the document body. |
+| `apply_text_style` | Applies character-level formatting (e.g., bold, italic, color, links) to a specified text range. This function modifies text attributes directly, distinguishing it from `update_paragraph_style` which handles block-level properties like alignment. |
+| `update_paragraph_style` | Applies paragraph-level formatting like alignment, named styles (e.g., 'HEADING_1'), and text direction to a text range in a Google Doc. Distinct from `apply_text_style`, which handles character formatting, this method modifies properties for entire paragraphs using the batchUpdate API. |
+| `delete_content_range` | Removes content from a specified index range in a Google Document via the batchUpdate API. Unlike functions that delete entire elements (e.g., `delete_header`), this provides granular control by targeting content based on its precise start and end location, optionally within a specific segment or tab. |
+| `insert_table` | Inserts a table with specified rows and columns at a given index in a Google Document using the batchUpdate API. It can optionally place the table within specific document segments, such as headers or footers, handling structural additions rather than text or style modifications. |
+| `create_footer` | Creates a footer of a specified type in a Google Document using the batch update API. This function, distinct from `create_header`, can optionally associate the new footer with a specific section break, enabling section-specific footers within the document. |
+| `create_footnote` | Inserts a numbered footnote reference into a Google Document using the batchUpdate API. The footnote can be placed at a precise index or at the end of a document segment, distinct from the `create_footer` function which adds standard page footers. |
+| `delete_footer` | Deletes a specific footer from a Google Document using its unique ID via a batchUpdate API request. This operation removes the entire footer object, optionally within a specific tab, distinguishing it from functions that delete headers (`delete_header`) or general content (`delete_content_range`). |
+| `create_header` | Creates a header of a specified type in a Google Document using the batchUpdate API. This function can optionally associate the new header with a specific section break, distinguishing it from the `create_footer` method, which performs the equivalent action for footers. |
+| `delete_header` | Deletes a specific header from a Google Document using its unique ID via a batchUpdate API request. This function, the counterpart to `create_header`, removes headers and can optionally target a header within a specific tab. It requires both the document and header IDs for the operation. |
+| `apply_list_style` | Applies a predefined list style (bulleted or numbered) to paragraphs within a specified range using a chosen preset. Unlike `delete_paragraph_bullets`, which removes list formatting, this function creates it, distinguishing it from other text and paragraph styling methods in the class. |
+| `delete_paragraph_bullets` | Removes bullet points or numbering from paragraphs within a specified index range in a Google Document. This reverts list formatting to normal text while preserving content, acting as the inverse operation to the `apply_list_style` function. |

universal_mcp/applications/google_docs/app.py

@@ -33,7 +33,7 @@ class GoogleDocsApp(APIApplication):
         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]:
+    async def get_document(self, document_id: str) -> dict[str, Any]:
         """
         Retrieves the complete, raw JSON object for a Google Document by its ID. This function returns the full, unprocessed API response with all metadata and structural elements, distinguishing it from `get_document_content`, which parses this data to extract only the title and plain text.
 
@@ -51,7 +51,7 @@ class GoogleDocsApp(APIApplication):
             retrieve, read, api, document, google-docs, important
         """
         url = f"{self.base_api_url}/{document_id}"
-        response = self._get(url)
+        response = await self._aget(url)
         return response.json()
 
     async def get_document_content(self, document_id: str) -> dict[str, Any]:
@@ -85,7 +85,7 @@ class GoogleDocsApp(APIApplication):
         """
         import re
 
-        response = self.get_document(document_id)
+        response = await self.get_document(document_id)
         title = response.get("title", "")
         body_content = response.get("body", {}).get("content", [])
         inline_objects = response.get("inlineObjects", {})
@@ -714,9 +714,11 @@ class GoogleDocsApp(APIApplication):
     def list_tools(self):
         return [
             self.create_document,
+            self.get_document,
             self.get_document_content,
             self.insert_text,
             self.apply_text_style,
+            self.update_paragraph_style,
             self.delete_content_range,
             self.insert_table,
             self.create_footer,
@@ -726,5 +728,4 @@ class GoogleDocsApp(APIApplication):
             self.delete_header,
             self.apply_list_style,
             self.delete_paragraph_bullets,
-            self.update_paragraph_style,
         ]

universal_mcp/applications/google_gemini/app.py

@@ -16,11 +16,10 @@ class GoogleGeminiApp(APIApplication):
         super().__init__(name="google_gemini", integration=integration, **kwargs)
         self._genai_client = None
 
-    @property
-    def genai_client(self) -> genai.Client:
+    async def get_genai_client(self) -> genai.Client:
         if self._genai_client is not None:
             return self._genai_client
-        credentials = self.integration.get_credentials()
+        credentials = await self.integration.get_credentials_async()
         api_key = credentials.get("api_key") or credentials.get("API_KEY") or credentials.get("apiKey")
         if not api_key:
             raise ValueError("API key not found in integration credentials")
@@ -54,17 +53,15 @@ class GoogleGeminiApp(APIApplication):
         Tags:
             text, generate, llm, important
         """
-        response = self.genai_client.models.generate_content(contents=prompt, model=model)
+        client = await self.get_genai_client()
+        response = client.models.generate_content(contents=prompt, model=model)
         return response.text
 
     async def generate_image(
         self,
         prompt: Annotated[str, "The prompt to generate image from"],
         images: Annotated[list[str], "The reference image URLs"] | None = None,
-        model: Literal[
-            "gemini-3-pro-image-preview",
-            "gemini-2.5-flash-image"
-        ] = "gemini-2.5-flash-image",
+        model: Literal["gemini-3-pro-image-preview", "gemini-2.5-flash-image"] = "gemini-2.5-flash-image",
     ) -> dict:
         """
         Generates an image based on a text prompt and an optional reference image using the Google Gemini model.
@@ -74,7 +71,7 @@ class GoogleGeminiApp(APIApplication):
         Args:
             prompt (str): The descriptive text prompt to guide the image generation. For example: "A futuristic city at sunset with flying cars."
             images (list[str], optional): An optional list of URLs to reference images. These images will be used as a basis for the generation.
-            model (str, optional): The Gemini model to use for image generation. Defaults to "gemini-2.5-flash-image". 
+            model (str, optional): The Gemini model to use for image generation. Defaults to "gemini-2.5-flash-image".
 
         Returns:
             dict: A dictionary containing:
@@ -92,6 +89,7 @@ class GoogleGeminiApp(APIApplication):
         Tags:
             image, generate, vision, important
         """
+        client = await self.get_genai_client()
         contents = [prompt]
         if images:
             for image in images:
@@ -104,7 +102,7 @@ class GoogleGeminiApp(APIApplication):
                 else:
                     image = Image.open(image)
                 contents.append(image)
-        response = self.genai_client.models.generate_content(model=model, contents=contents)
+        response = client.models.generate_content(model=model, contents=contents)
         candidate = response.candidates[0]
         text = ""
         for part in candidate.content.parts:
@@ -119,11 +117,8 @@ class GoogleGeminiApp(APIApplication):
     async def generate_audio(
         self,
         prompt: Annotated[str, "The prompt to generate audio from"],
-        model: Literal[
-            "gemini-2.5-flash-preview-tts",
-            "gemini-2.5-pro-preview-tts"
-        ] = "gemini-2.5-flash-preview-tts",
-    ) -> str:  
+        model: Literal["gemini-2.5-flash-preview-tts", "gemini-2.5-pro-preview-tts"] = "gemini-2.5-flash-preview-tts",
+    ) -> str:
         """Generates audio from a given text prompt using the Google Gemini model's Text-to-Speech (TTS) capabilities.
         This tool is useful for converting text into spoken audio, which can be used for voiceovers, accessibility features, or interactive applications.
         It returns a dictionary containing the generated audio data (base64 encoded), its MIME type, and a suggested file name.
@@ -145,6 +140,7 @@ class GoogleGeminiApp(APIApplication):
         Tags:
             audio, generate, tts, speech, important
         """
+        client = await self.get_genai_client()
 
         def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
             with wave.open(filename, "wb") as wf:
@@ -153,7 +149,7 @@ class GoogleGeminiApp(APIApplication):
                 wf.setframerate(rate)
                 wf.writeframes(pcm)
 
-        response = self.genai_client.models.generate_content(
+        response = client.models.generate_content(
             model=model,
             contents=prompt,
             config=types.GenerateContentConfig(
@@ -174,8 +170,56 @@ class GoogleGeminiApp(APIApplication):
         audio_base64 = base64.b64encode(data).decode("utf-8")
         return {"type": "audio", "data": audio_base64, "mime_type": "audio/wav", "file_name": file_name}
 
+    async def analyze_image(
+        self,
+        images: Annotated[list[str], "The reference image URLs"],
+        prompt: Annotated[str, "The prompt to describe or ask about the image"] = "Describe this image",
+        model: Literal["gemini-2.5-flash", "gemini-2.5-pro"] = "gemini-2.5-flash",
+    ) -> str:
+        """
+        Analyzes one or more images based on a text prompt using the Google Gemini model.
+        This tool is capable of describing images, answering questions about them, or performing visual reasoning.
+        It accepts image URLs and a text prompt, returning a natural language response.
+
+        Args:
+            images (list[str]): A list of URLs for the images to be analyzed.
+            prompt (str, optional): The text prompt or question about the images. Defaults to "Describe this image".
+            model (str, optional): The Gemini model to use for analysis. Defaults to "gemini-2.5-flash".
+
+        Returns:
+            str: The generated text response containing the analysis or description of the images.
+
+        Raises:
+            requests.exceptions.RequestException: If there's an issue fetching a remote image.
+            FileNotFoundError: If a local image path is invalid.
+            Exception: If the underlying Gemini API call fails.
+
+        Tags:
+            image, analyze, vision, describe, question, important
+        """
+        client = await self.get_genai_client()
+        contents = [prompt]
+        if images:
+            for image in images:
+                if image.startswith(("http://", "https://")):
+                    import requests
+
+                    response = requests.get(image)
+                    response.raise_for_status()
+                    image = Image.open(io.BytesIO(response.content))
+                else:
+                    image = Image.open(image)
+                contents.append(image)
+        response = client.models.generate_content(model=model, contents=contents)
+        return response.text
+
     def list_tools(self):
-        return [self.generate_text, self.generate_image, self.generate_audio]
+        return [
+            self.generate_text,
+            self.generate_image,
+            self.analyze_image,
+            self.generate_audio,
+        ]
 
 
 async def test_google_gemini():

universal_mcp/applications/google_sheet/README.md

@@ -9,7 +9,7 @@ This is automatically generated from OpenAPI schema for the GoogleSheetApp API.
 
 | Tool | Description |
 |------|-------------|
-| `create_spreadsheet` | 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. |
+| `create_spreadsheet` | 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. |
 | `get_spreadsheet_metadata` | Retrieves a spreadsheet's metadata and structural properties, such as sheet names, IDs, and named ranges, using its unique ID. This function intentionally excludes cell data, distinguishing it from `get_values` which fetches the actual content within cells. |
 | `get_values` | Retrieves cell values from a single, specified A1 notation range. Unlike `batch_get_values_by_range` which fetches multiple ranges, this function is for a singular query and provides options to control the data's output format (e.g., rows vs. columns, formatted vs. raw values). |
 | `batch_get_values_by_range` | Efficiently retrieves values from multiple predefined A1 notation ranges in a single API request. Unlike `get_values`, which fetches a single range, or `batch_get_values_by_data_filter`, which uses dynamic filtering criteria, this function operates on a simple list of range strings for bulk data retrieval. |
@@ -34,3 +34,4 @@ This is automatically generated from OpenAPI schema for the GoogleSheetApp API.
 | `analyze_table_schema` | Infers a specified table's schema by analyzing a data sample. After locating the table by name (a value discovered via `discover_tables`), this function determines the most likely data type and properties for each column, providing a detailed structural breakdown of its content. |
 | `set_basic_filter` | Sets or updates a basic filter on a specified range within a sheet, enabling data sorting and filtering. The filter's target range and optional sort specifications are defined in a dictionary argument. It is the counterpart to `clear_basic_filter`, which removes an existing filter. |
 | `format_cells` | Applies comprehensive formatting to a specified cell range in a worksheet. It modifies visual properties like text style, color, alignment, borders, and can merge cells, without altering the underlying cell values, distinguishing it from data-modification functions like `update_values`. |
+| `batch_update_values` | Updates multiple ranges of values in a spreadsheet in a single batch request. This method allows you to update several disjoint ranges or multiple sheets simultaneously, which is more efficient than making separate calls for each range. |

universal_mcp/applications/google_sheet/app.py

@@ -1455,6 +1455,60 @@ class GoogleSheetApp(APIApplication):
         response = await self._apost(url, data=request_body)
         return self._handle_response(response)
 
+    async def batch_update_values(
+        self,
+        spreadsheetId: str,
+        data: list[dict],
+        value_input_option: str = "USER_ENTERED",
+        include_values_in_response: bool = False,
+        response_value_render_option: str | None = None,
+        response_date_time_render_option: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Updates multiple ranges of values in a spreadsheet in a single batch request. This method allows you to update several disjoint ranges or multiple sheets simultaneously, which is more efficient than making separate calls for each range.
+
+        Args:
+            spreadsheetId: The unique identifier of the Google Spreadsheet to update. Example: "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms"
+            data: A list of dictionaries, where each dictionary represents a range to update. Each dictionary must contain:
+                - range: The A1 notation of the range to update (e.g., "Sheet1!A1:B2").
+                - values: A 2D list of values to write into that range.
+                Example: [{"range": "Sheet1!A1", "values": [["Header"]]}, {"range": "Sheet2!B2", "values": [[100]]}]
+            value_input_option: How the input data should be interpreted. Options: "RAW" (as-is) or "USER_ENTERED" (parsed as if typed by user). Defaults to "USER_ENTERED".
+            include_values_in_response: If True, the response will include the values of the cells that were updated. Defaults to False.
+            response_value_render_option: Determines how values in the response should be rendered. Options: "FORMATTED_VALUE", "UNFORMATTED_VALUE", "FORMULA".
+            response_date_time_render_option: Determines how dates/times in the response should be rendered. Options: "SERIAL_NUMBER", "FORMATTED_STRING".
+
+        Returns:
+            A dictionary containing the Google Sheets API response with details of the batch update.
+
+        Raises:
+            HTTPError: When the API request fails due to invalid parameters or insufficient permissions
+            ValueError: When spreadsheetId is empty or data is empty
+
+        Tags:
+            batch, update, values, spreadsheet, write, important
+        """
+        if not spreadsheetId:
+            raise ValueError("spreadsheetId cannot be empty")
+        if not data:
+            raise ValueError("data cannot be empty")
+
+        url = f"{self.base_url}/{spreadsheetId}/values:batchUpdate"
+
+        request_body = {
+            "valueInputOption": value_input_option,
+            "data": data,
+            "includeValuesInResponse": include_values_in_response,
+        }
+
+        if response_value_render_option:
+            request_body["responseValueRenderOption"] = response_value_render_option
+        if response_date_time_render_option:
+            request_body["responseDateTimeRenderOption"] = response_date_time_render_option
+
+        response = await self._apost(url, data=request_body)
+        return self._handle_response(response)
+
     def list_tools(self):
         """Returns a list of methods exposed as tools."""
         return [
@@ -1483,4 +1537,5 @@ class GoogleSheetApp(APIApplication):
             self.analyze_table_schema,
             self.set_basic_filter,
             self.format_cells,
+            self.batch_update_values,
         ]

universal_mcp/applications/heygen/README.md

@@ -9,36 +9,14 @@ This is automatically generated from OpenAPI schema for the HeygenApp API.
 
 | Tool | Description |
 |------|-------------|
-| `get_v1_voice_list` | Retrieves the list of available voices from the v1 voice API endpoint. |
-| `get_v1_avatar_list` | Retrieves a list of available avatars from the v1 API endpoint. |
-| `get_v2_voices` | Retrieves the list of available v2 voices from the API endpoint. |
 | `get_v2_avatars` | Retrieves a list of avatar objects from the /v2/avatars API endpoint. |
-| `get_v1_video_list` | Retrieves a list of videos from the v1 API endpoint. |
-| `post_v2_video_generate` | Submits a request to generate a video using specified input parameters via the v2 video generate API endpoint. |
-| `delete_v1_video` | Deletes a video using the v1 API endpoint with the specified video ID. |
-| `get_v2_templates` | Retrieves the list of v2 templates from the API endpoint. |
-| `get_v2_template_by_id` | Retrieves a v2 template resource by its unique identifier. |
-| `post_v2_template_generate_by_id` | Generates content from a template specified by ID using the provided title and variables, and returns the generation result. |
-| `get_v2_video_translate_target_languages` | Retrieves the list of supported target languages for video translation via the v2 API. |
-| `post_v2_video_translate` | Submits a video translation request and returns the API response as JSON. |
-| `get_v2_video_translate_status_by_id` | Retrieves the status of a video translation job by its unique identifier. |
-| `post_streaming_new` | Initiates a new streaming session with optional quality parameter and returns the server's JSON response. |
-| `get_streaming_list` | Retrieves the list of available streaming resources from the remote API. |
-| `post_streaming_ice` | Sends an ICE candidate for a streaming session to the server and returns the JSON response. |
-| `post_streaming_task` | Submits a streaming task for the specified session and text input, returning the response from the remote API. |
-| `post_streaming_stop` | Stops an ongoing streaming session by sending a stop request for the specified session ID. |
-| `post_streaming_interrupt` | Sends a request to interrupt an active streaming session identified by the given session ID. |
-| `post_streaming_create_token` | Creates a new streaming token with an optional expiry time by sending a POST request to the streaming token API endpoint. |
-| `get_streaming_avatar_list` | Retrieves a list of available streaming avatars from the API endpoint. |
-| `get_v1_webhook_list` | Retrieves a list of all registered webhooks via the v1 API endpoint. |
-| `post_v1_webhook_endpoint_add` | Registers a new webhook endpoint with the specified URL and events. |
-| `delete_v1_webhook_endpoint_by_id` | Deletes a webhook endpoint identified by its ID via a DELETE request to the v1 API. |
-| `get_v1_webhook_endpoint_list` | Retrieves a list of webhook endpoints from the v1 API. |
-| `get_v1_talking_photo_list` | Retrieves the list of talking photos from the v1 API endpoint. |
-| `delete_v2_talking_photo_by_id` | Deletes a v2 talking photo resource identified by its unique ID. |
-| `post_personalized_video_add_contact` | Adds a new contact to a personalized video project by sending the contact variables to the server. |
-| `get_personalized_video_audience_detail` | Retrieves detailed information about a personalized video audience by ID. |
-| `get_personalized_video_project_detail` | Retrieves the details of a personalized video project by its unique identifier. |
-| `get_v2_user_remaining_quota` | Retrieves the current remaining quota information for the user from the v2 API endpoint. |
-| `post_v1_asset_upload` | Uploads an asset to the server using a POST request to the '/v1/asset' endpoint. |
-| `get_v1_video_status` | Retrieves the status of a video by making a GET request to the v1 video_status endpoint. |
+| `list_avatar_groups` | Retrieves a list of avatar groups from the /v2/avatar_group.list API endpoint. |
+| `list_avatars_in_group` | Retrieves a list of avatars from a specific avatar group. |
+| `get_avatar_details` | Retrieves detailed information about a specific avatar by its ID. |
+| `create_avatar_video` | Creates a new avatar video using the /v2/video/generate API endpoint. |
+| `get_video_status` | Retrieves the status and details of a specific video by ID using the /v1/video_status.get endpoint. |
+| `create_folder` | Creates a new folder under your account using the /v1/folders/create endpoint. |
+| `list_folders` | Retrieves a paginated list of folders created under your account using the /v1/folders endpoint. |
+| `update_folder` | Updates the name of an existing folder using the /v1/folders/{folder_id} endpoint. |
+| `trash_folder` | Deletes (trashes) a specific folder by its unique folder ID using the /v1/folders/{folder_id}/trash endpoint. |
+| `restore_folder` | Restores a previously deleted folder using the /v1/folders/{folder_id}/restore endpoint. |