universal-mcp-applications 0.1.33__py3-none-any.whl → 0.1.39rc16__py3-none-any.whl

universal_mcp/applications/google_gemini/app.py

@@ -3,8 +3,7 @@ import io
 import os
 import uuid
 import wave
-from typing import Annotated
-
+from typing import Annotated, Literal
 from google import genai
 from google.genai import types
 from PIL import Image
@@ -17,16 +16,11 @@ 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()
-        api_key = (
-            credentials.get("api_key")
-            or credentials.get("API_KEY")
-            or credentials.get("apiKey")
-        )
+        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")
         self._genai_client = genai.Client(api_key=api_key)
@@ -35,7 +29,12 @@ class GoogleGeminiApp(APIApplication):
     async def generate_text(
         self,
         prompt: Annotated[str, "The prompt to generate text from"],
-        model: str = "gemini-2.5-flash",
+        model: Literal[
+            "gemini-2.5-flash",
+            "gemini-2.5-pro",
+            "gemini-3-flash-preview",
+            "gemini-3-pro-preview",
+        ] = "gemini-2.5-flash",
     ) -> str:
         """Generates text using the Google Gemini model based on a given prompt.
         This tool is suitable for various natural language processing tasks such as content generation, summarization, translation, and question answering.
@@ -54,16 +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: str = "gemini-2.5-flash-image-preview",
+        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",
     ) -> dict:
         """
         Generates an image based on a text prompt and an optional reference image using the Google Gemini model.
@@ -73,12 +71,12 @@ 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-preview".
+            model (str, optional): The Gemini model to use for image generation. Defaults to "gemini-2.5-flash-image".
 
         Returns:
             dict: A dictionary containing:
                 - 'type' (str): Always "image".
-                - 'data' (str): The base64 encoded image data.
+                - 'data' (str): The base64 encoded image data. Either upload or save this and then render the file path/link in markdown to the user. DO NOT use a data url.
                 - 'mime_type' (str): The MIME type of the image (e.g., "image/png").
                 - 'file_name' (str): A suggested file name for the generated image.
                 - 'text' (str): Any accompanying text generated by the model.
@@ -91,7 +89,7 @@ class GoogleGeminiApp(APIApplication):
         Tags:
             image, generate, vision, important
         """
-        # The Gemini API is synchronous, so run in a thread
+        client = await self.get_genai_client()
         contents = [prompt]
         if images:
             for image in images:
@@ -104,35 +102,22 @@ 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:
             if part.text is not None:
                 text += part.text
             elif part.inline_data is not None:
-                # Return the raw image bytes
                 image_bytes = part.inline_data.data
-
                 img_base64 = base64.b64encode(image_bytes).decode("utf-8")
-
                 file_name = f"{uuid.uuid4()}.png"
-
-                return {
-                    "type": "image",
-                    "data": img_base64,
-                    "mime_type": "image/png",
-                    "file_name": file_name,
-                    "text": text,
-                }
+                return {"type": "image", "data": img_base64, "mime_type": "image/png", "file_name": file_name, "text": text}
 
     async def generate_audio(
         self,
         prompt: Annotated[str, "The prompt to generate audio from"],
-        model: str = "gemini-2.5-flash-preview-tts",
+        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.
@@ -155,8 +140,8 @@ class GoogleGeminiApp(APIApplication):
         Tags:
             audio, generate, tts, speech, important
         """
+        client = await self.get_genai_client()
 
-        # Set up the wave file to save the output:
         def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
             with wave.open(filename, "wb") as wf:
                 wf.setnchannels(channels)
@@ -164,58 +149,82 @@ 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(
                 response_modalities=["AUDIO"],
                 speech_config=types.SpeechConfig(
-                    voice_config=types.VoiceConfig(
-                        prebuilt_voice_config=types.PrebuiltVoiceConfig(
-                            voice_name="Kore",
-                        )
-                    )
+                    voice_config=types.VoiceConfig(prebuilt_voice_config=types.PrebuiltVoiceConfig(voice_name="Kore"))
                 ),
             ),
         )
-
         data = response.candidates[0].content.parts[0].inline_data.data
-
         file_name = f"{uuid.uuid4()}.wav"
         wave_file(file_name, data)
-
-        # read the file
         with open(file_name, "rb") as f:
             data = f.read()
-
-        # delete the file
         os.remove(file_name)
-
-        # Convert to base64
         import base64
 
         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.
 
-        return {
-            "type": "audio",
-            "data": audio_base64,
-            "mime_type": "audio/wav",
-            "file_name": file_name,
-        }
+        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.analyze_image,
             self.generate_audio,
         ]
 
 
 async def test_google_gemini():
     app = GoogleGeminiApp()
-    await app.generate_image(
-        "A beautiful women potrait with red green hair color"
-    )
+    await app.generate_image("A beautiful women potrait with red green hair color")
 
 
 if __name__ == "__main__":

universal_mcp/applications/google_mail/README.md

@@ -16,6 +16,7 @@ This is automatically generated from OpenAPI schema for the GoogleMailApp API.
 | `list_drafts` | Fetches a list of email drafts, allowing filtering by a search query and limiting results. It can optionally include drafts from spam and trash, returning a collection of draft objects. This is distinct from `get_draft`, which retrieves only a single, specific draft by its ID. |
 | `get_message_details` | Retrieves a specific email from Gmail by its ID. It parses the API response to extract and format key details—including sender, subject, body, and attachments—into a structured dictionary. This function provides detailed data for a single message, distinguishing it from `list_messages` which fetches multiple messages. |
 | `list_messages` | Fetches a paginated list of detailed email messages using optional search queries. It concurrently retrieves full content (sender, subject, body) for each message, returning the results and a pagination token. This differs from `get_message_details`, which fetches only a single message. |
+| `get_email_thread` | Fetches a complete email conversation by its unique thread ID. Unlike `get_message_details`, which retrieves a single message, this returns all messages and metadata for the entire thread, providing the full context of the conversation. |
 | `list_labels` | Fetches a complete list of all available labels from the user's Gmail account via the API. It retrieves both system-defined (e.g., INBOX) and user-created labels, returning their names and IDs, complementing management functions like `create_label` and `update_label`. |
 | `create_label` | Creates a new Gmail label with a specified name, hardcoding its visibility to ensure it appears in both label and message lists. This function complements `update_label` and `delete_label` by adding new organizational tags to the user's account via the API. |
 | `get_profile` | Retrieves the authenticated user's Gmail profile from the API. The profile includes the user's email address, total message and thread counts, and the mailbox's history ID, offering a high-level summary of the account's state. |