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

universal_mcp/applications/openai/app.py

@@ -1,18 +1,11 @@
 import base64
 from typing import Any, Literal
-
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
-
 from openai import NOT_GIVEN, AsyncOpenAI, OpenAIError
 from openai._types import FileTypes as OpenAiFileTypes
 from openai.types import FilePurpose as OpenAiFilePurpose
-from openai.types.audio import (
-    Transcription,
-    TranscriptionVerbose,
-    Translation,
-    TranslationVerbose,
-)
+from openai.types.audio import Transcription, TranscriptionVerbose, Translation, TranslationVerbose
 from openai.types.audio.speech_model import SpeechModel as OpenAiSpeechModel
 from openai.types.audio_model import AudioModel as OpenAiAudioModel
 from openai.types.chat import ChatCompletionMessageParam
@@ -35,22 +28,16 @@ class OpenaiApp(APIApplication):
         """Initializes and returns the AsyncOpenAI client."""
         if not self.integration:
             raise ValueError("Integration not provided for OpenaiApp.")
-
-        creds = self.integration.get_credentials()
+        creds = await self.integration.get_credentials_async()
         api_key = creds.get("api_key")
         organization = creds.get("organization")
         project = creds.get("project")
-
-        return AsyncOpenAI(
-            api_key=api_key,
-            organization=organization,
-            project=project,
-        )
+        return AsyncOpenAI(api_key=api_key, organization=organization, project=project)
 
     async def create_chat_completion(
         self,
         messages: list[ChatCompletionMessageParam],
-        model: str = "gpt-4o",  # Default model set to gpt-4o
+        model: str = "gpt-4o",
         stream: bool = False,
         temperature: float | None = None,
         max_tokens: int | None = None,
@@ -59,7 +46,6 @@ class OpenaiApp(APIApplication):
         presence_penalty: float | None = None,
         stop: str | None | list[str] = None,
         user: str | None = None,
-        # Add other common parameters as needed, or rely on
     ) -> dict[str, Any] | str:
         """
         Generates a model response for a chat conversation. It supports both standard and streaming modes; if streaming, it internally aggregates response chunks into a single complete object, simplifying stream handling. Returns the completion data as a dictionary on success or an error string on failure.
@@ -103,22 +89,15 @@ class OpenaiApp(APIApplication):
                 "user": user,
             }
             common_params = {k: v for k, v in common_params.items() if v is not None}
-
             if not stream:
-                response = await client.chat.completions.create(
-                    stream=False, **common_params
-                )
+                response = await client.chat.completions.create(stream=False, **common_params)
                 return response.model_dump()
             else:
-                stream_response = await client.chat.completions.create(
-                    stream=True, **common_params
-                )
-
+                stream_response = await client.chat.completions.create(stream=True, **common_params)
                 final_content_parts: list[str] = []
                 final_role: str = "assistant"
                 first_chunk_data: dict[str, Any] = {}
                 finish_reason: str | None = None
-
                 async for chunk in stream_response:
                     if not first_chunk_data and chunk.id:
                         first_chunk_data = {
@@ -127,7 +106,6 @@ class OpenaiApp(APIApplication):
                             "model": chunk.model,
                             "system_fingerprint": chunk.system_fingerprint,
                         }
-
                     if chunk.choices:
                         choice = chunk.choices[0]
                         if choice.delta:
@@ -137,32 +115,19 @@ class OpenaiApp(APIApplication):
                                 final_role = choice.delta.role
                         if choice.finish_reason:
                             finish_reason = choice.finish_reason
-
                 aggregated_choice = {
-                    "message": {
-                        "role": final_role,
-                        "content": "".join(final_content_parts),
-                    },
+                    "message": {"role": final_role, "content": "".join(final_content_parts)},
                     "finish_reason": finish_reason,
                     "index": 0,
                 }
-
-                response_dict = {
-                    **first_chunk_data,
-                    "object": "chat.completion",
-                    "choices": [aggregated_choice],
-                    "usage": None,
-                }
+                response_dict = {**first_chunk_data, "object": "chat.completion", "choices": [aggregated_choice], "usage": None}
                 return response_dict
-
         except OpenAIError as e:
             return f"OpenAI API error creating chat completion for model {model}: {type(e).__name__} - {e}"
         except Exception as e:
             return f"Error creating chat completion for model {model}: {type(e).__name__} - {e}"
 
-    async def upload_file(
-        self, file: OpenAiFileTypes, purpose: OpenAiFilePurpose
-    ) -> dict[str, Any] | str:
+    async def upload_file(self, file: OpenAiFileTypes, purpose: OpenAiFilePurpose) -> dict[str, Any] | str:
         """
         Uploads a file to the user's OpenAI account for use across various endpoints like 'assistants'. It accepts a file path or object and a purpose string, returning a dictionary with the created file object's details upon success.
 
@@ -188,11 +153,7 @@ class OpenaiApp(APIApplication):
             return f"Error uploading file: {type(e).__name__} - {e}"
 
     async def list_files(
-        self,
-        purpose: str | None = None,
-        limit: int | None = None,
-        after: str | None = None,
-        order: Literal["asc", "desc"] | None = None,
+        self, purpose: str | None = None, limit: int | None = None, after: str | None = None, order: Literal["asc", "desc"] | None = None
     ) -> dict[str, Any] | str:
         """
         Retrieves a paginated list of files uploaded to the OpenAI account. Allows filtering by purpose and controlling the output with limit, `after` cursor, and sort order parameters to efficiently navigate through the file collection.
@@ -221,7 +182,6 @@ class OpenaiApp(APIApplication):
                 params["after"] = after
             if order:
                 params["order"] = order
-
             response_page = await client.files.list(**params)
             return response_page.model_dump()
         except OpenAIError as e:
@@ -248,9 +208,7 @@ class OpenaiApp(APIApplication):
             response: FileObject = await client.files.retrieve(file_id=file_id)
             return response.model_dump()
         except OpenAIError as e:
-            return (
-                f"OpenAI API error retrieving file {file_id}: {type(e).__name__} - {e}"
-            )
+            return f"OpenAI API error retrieving file {file_id}: {type(e).__name__} - {e}"
         except Exception as e:
             return f"Error retrieving file {file_id}: {type(e).__name__} - {e}"
 
@@ -294,25 +252,19 @@ class OpenaiApp(APIApplication):
         try:
             client = await self._get_client()
             api_response = await client.files.content(file_id=file_id)
-
             http_response_headers = api_response.response.headers
             content_type = http_response_headers.get("Content-Type", "").lower()
-
             if (
                 "text" in content_type
                 or "json" in content_type
                 or "xml" in content_type
-                or "javascript" in content_type
-                or "csv" in content_type
+                or ("javascript" in content_type)
+                or ("csv" in content_type)
             ):
-                return api_response.text  # Decoded text
+                return api_response.text
             else:
                 binary_content = api_response.content
-                return {
-                    "file_id": file_id,
-                    "content_type": content_type,
-                    "content_base64": base64.b64encode(binary_content).decode(),
-                }
+                return {"file_id": file_id, "content_type": content_type, "content_base64": base64.b64encode(binary_content).decode()}
         except UnicodeDecodeError:
             client = await self._get_client()
             api_response = await client.files.content(file_id=file_id)
@@ -327,23 +279,17 @@ class OpenaiApp(APIApplication):
         except OpenAIError as e:
             return f"OpenAI API error retrieving content for file {file_id}: {type(e).__name__} - {e}"
         except Exception as e:
-            return (
-                f"Error retrieving content for file {file_id}: {type(e).__name__} - {e}"
-            )
+            return f"Error retrieving content for file {file_id}: {type(e).__name__} - {e}"
 
-    # --- Images Methods ---
     async def create_image(
         self,
         prompt: str,
-        model: str
-        | OpenAiImageModel
-        | None = "dall-e-3",  # Default model set to dall-e-3
-        n: int | None = None,  # 1-10 for dall-e-2, 1 for dall-e-3
-        quality: Literal["standard", "hd"] | None = None,  # For dall-e-3
+        model: str | OpenAiImageModel | None = "dall-e-3",
+        n: int | None = None,
+        quality: Literal["standard", "hd"] | None = None,
         response_format: Literal["url", "b64_json"] | None = None,
-        size: Literal["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"]
-        | None = None,
-        style: Literal["vivid", "natural"] | None = None,  # For dall-e-3
+        size: Literal["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"] | None = None,
+        style: Literal["vivid", "natural"] | None = None,
         user: str | None = None,
     ) -> dict[str, Any] | str:
         """
@@ -375,11 +321,7 @@ class OpenaiApp(APIApplication):
         """
         try:
             client = await self._get_client()
-
-            effective_model = (
-                model if model is not None else "dall-e-3"
-            )  # Ensure effective_model is not None
-
+            effective_model = model if model is not None else "dall-e-3"
             effective_params = {
                 "prompt": prompt,
                 "model": effective_model,
@@ -390,19 +332,13 @@ class OpenaiApp(APIApplication):
                 "style": style,
                 "user": user,
             }
-
-            effective_params = {
-                k: v for k, v in effective_params.items() if v is not None
-            }
-
+            effective_params = {k: v for k, v in effective_params.items() if v is not None}
             response = await client.images.generate(**effective_params)
             return response.model_dump()
         except OpenAIError as e:
             return f"OpenAI API error generating image with model {model}: {type(e).__name__} - {e}"
         except Exception as e:
-            return (
-                f"Error generating image with model {model}: {type(e).__name__} - {e}"
-            )
+            return f"Error generating image with model {model}: {type(e).__name__} - {e}"
 
     async def create_image_edit(
         self,
@@ -439,7 +375,6 @@ class OpenaiApp(APIApplication):
         try:
             client = await self._get_client()
             effective_model = model if model is not None else "dall-e-2"
-
             params = {
                 "image": image,
                 "prompt": prompt,
@@ -451,7 +386,6 @@ class OpenaiApp(APIApplication):
                 "user": user,
             }
             params = {k: v for k, v in params.items() if v is not None}
-
             response = await client.images.edit(**params)
             return response.model_dump()
         except OpenAIError as e:
@@ -490,17 +424,8 @@ class OpenaiApp(APIApplication):
         try:
             client = await self._get_client()
             effective_model = model if model is not None else "dall-e-2"
-
-            params = {
-                "image": image,
-                "model": effective_model,
-                "n": n,
-                "response_format": response_format,
-                "size": size,
-                "user": user,
-            }
+            params = {"image": image, "model": effective_model, "n": n, "response_format": response_format, "size": size, "user": user}
             params = {k: v for k, v in params.items() if v is not None}
-
             response = await client.images.create_variation(**params)
             return response.model_dump()
         except OpenAIError as e:
@@ -514,11 +439,10 @@ class OpenaiApp(APIApplication):
         model: str | OpenAiAudioModel = "gpt-4o-transcribe",
         language: str | None = None,
         prompt: str | None = None,
-        response_format: Literal["json", "text", "srt", "verbose_json", "vtt"]
-        | None = None,
+        response_format: Literal["json", "text", "srt", "verbose_json", "vtt"] | None = None,
         temperature: float | None = None,
         timestamp_granularities: list[Literal["word", "segment"]] | None = None,
-        include: list[Literal["logprobs"]] | None = None,  # For gpt-4o models
+        include: list[Literal["logprobs"]] | None = None,
         stream: bool = False,
     ) -> dict[str, Any] | str:
         """
@@ -550,56 +474,36 @@ class OpenaiApp(APIApplication):
         """
         try:
             client = await self._get_client()
-
             params = {
                 "file": file,
                 "model": model,
                 "language": language if language is not None else NOT_GIVEN,
                 "prompt": prompt if prompt is not None else NOT_GIVEN,
-                "response_format": response_format
-                if response_format is not None
-                else NOT_GIVEN,
+                "response_format": response_format if response_format is not None else NOT_GIVEN,
                 "temperature": temperature if temperature is not None else NOT_GIVEN,
-                "timestamp_granularities": timestamp_granularities
-                if timestamp_granularities is not None
-                else NOT_GIVEN,
+                "timestamp_granularities": timestamp_granularities if timestamp_granularities is not None else NOT_GIVEN,
                 "include": include if include is not None else NOT_GIVEN,
             }
-
             if stream:
-                stream_response = await client.audio.transcriptions.create(
-                    **params, stream=True
-                )
-
+                stream_response = await client.audio.transcriptions.create(**params, stream=True)
                 final_transcription_value = None
                 async for event in stream_response:
-                    if hasattr(event, "value") and isinstance(
-                        event.value, Transcription | TranscriptionVerbose
-                    ):
+                    if hasattr(event, "value") and isinstance(event.value, Transcription | TranscriptionVerbose):
                         if event.__class__.__name__ == "FinalTranscriptionEvent":
                             final_transcription_value = event.value
                             break
-
                 if final_transcription_value:
                     return final_transcription_value.model_dump()
                 else:
-                    return {
-                        "error": "Stream aggregation failed to find final transcription object."
-                    }
+                    return {"error": "Stream aggregation failed to find final transcription object."}
             else:
-                response = await client.audio.transcriptions.create(
-                    **params, stream=False
-                )
+                response = await client.audio.transcriptions.create(**params, stream=False)
                 if isinstance(response, Transcription | TranscriptionVerbose):
                     return response.model_dump()
                 elif isinstance(response, str):
                     return response
                 else:
-                    return {
-                        "error": "Unexpected_response_type_from_transcription_api",
-                        "data": str(response),
-                    }
-
+                    return {"error": "Unexpected_response_type_from_transcription_api", "data": str(response)}
         except OpenAIError as e:
             return f"OpenAI API error creating transcription: {type(e).__name__} - {e}"
         except Exception as e:
@@ -610,8 +514,7 @@ class OpenaiApp(APIApplication):
         file: OpenAiFileTypes,
         model: str | OpenAiAudioModel = "whisper-1",
         prompt: str | None = None,
-        response_format: Literal["json", "text", "srt", "verbose_json", "vtt"]
-        | None = None,
+        response_format: Literal["json", "text", "srt", "verbose_json", "vtt"] | None = None,
         temperature: float | None = None,
     ) -> dict[str, Any] | str:
         """
@@ -637,22 +540,16 @@ class OpenaiApp(APIApplication):
                 "file": file,
                 "model": model,
                 "prompt": prompt if prompt is not None else NOT_GIVEN,
-                "response_format": response_format
-                if response_format is not None
-                else NOT_GIVEN,
+                "response_format": response_format if response_format is not None else NOT_GIVEN,
                 "temperature": temperature if temperature is not None else NOT_GIVEN,
             }
             response = await client.audio.translations.create(**params)
-
             if isinstance(response, Translation | TranslationVerbose):
                 return response.model_dump()
             elif isinstance(response, str):
                 return response
-            else:  # Should not happen
-                return {
-                    "error": "Unexpected_response_type_from_translation_api",
-                    "data": str(response),
-                }
+            else:
+                return {"error": "Unexpected_response_type_from_translation_api", "data": str(response)}
         except OpenAIError as e:
             return f"OpenAI API error creating translation: {type(e).__name__} - {e}"
         except Exception as e:
@@ -661,24 +558,11 @@ class OpenaiApp(APIApplication):
     async def create_speech(
         self,
         input_text: str,
-        voice: Literal[
-            "alloy",
-            "ash",
-            "ballad",
-            "coral",
-            "echo",
-            "fable",
-            "onyx",
-            "nova",
-            "sage",
-            "shimmer",
-            "verse",
-        ],
+        voice: Literal["alloy", "ash", "ballad", "coral", "echo", "fable", "onyx", "nova", "sage", "shimmer", "verse"],
         model: str | OpenAiSpeechModel = "tts-1",
-        response_format: Literal["mp3", "opus", "aac", "flac", "wav", "pcm"]
-        | None = None,  # Defaults to "mp3"
+        response_format: Literal["mp3", "opus", "aac", "flac", "wav", "pcm"] | None = None,
         speed: float | None = None,
-        instructions: str | None = None,  # For gpt-4o-mini-tts or newer models
+        instructions: str | None = None,
     ) -> dict[str, Any] | str:
         """
         Generates audio from input text using a specified TTS model and voice. This text-to-speech function allows customizing audio format and speed. On success, it returns a dictionary containing the base64-encoded audio content and its corresponding MIME type, or an error string on failure.
@@ -705,19 +589,13 @@ class OpenaiApp(APIApplication):
                 "input": input_text,
                 "model": model,
                 "voice": voice,
-                "response_format": response_format
-                if response_format is not None
-                else NOT_GIVEN,
+                "response_format": response_format if response_format is not None else NOT_GIVEN,
                 "speed": speed if speed is not None else NOT_GIVEN,
                 "instructions": instructions if instructions is not None else NOT_GIVEN,
             }
-
             api_response = await client.audio.speech.create(**params)
             binary_content = api_response.content
-            actual_content_type = api_response.response.headers.get(
-                "Content-Type", "application/octet-stream"
-            )
-
+            actual_content_type = api_response.response.headers.get("Content-Type", "application/octet-stream")
             if response_format and actual_content_type == "application/octet-stream":
                 mime_map = {
                     "mp3": "audio/mpeg",
@@ -728,7 +606,6 @@ class OpenaiApp(APIApplication):
                     "pcm": "audio/L16",
                 }
                 actual_content_type = mime_map.get(response_format, actual_content_type)
-
             return {
                 "model_used": str(model),
                 "voice_used": voice,

universal_mcp/applications/outlook/README.md

@@ -9,12 +9,25 @@ This is automatically generated from OpenAPI schema for the OutlookApp API.
 
 | Tool | Description |
 |------|-------------|
-| `reply_to_message` | Replies to an email using its message ID, with either a simple comment or a full message object including attachments. Unlike `send_mail`, which creates a new email, this function targets an existing message. It defaults to the current user if no user ID is specified. |
-| `send_mail` | Sends a new email on behalf of a specified or current user, using a dictionary for content like recipients and subject. Unlike `reply_to_message`, which replies to an existing message, this function composes and sends an entirely new email from scratch. |
-| `get_mail_folder` | Retrieves a specific mail folder's metadata by its ID for a given user. The response can be customized to include hidden folders or select specific properties. Unlike `list_user_messages`, this function fetches folder details, not the emails contained within it. |
-| `list_user_messages` | Retrieves a list of messages from a user's mailbox. This function supports powerful querying using optional parameters for filtering, searching, sorting, and pagination, unlike `get_user_message`, which fetches a single email by its ID. |
-| `get_user_message` | Retrieves a specific email message by its ID for a given user, with options to select specific fields or expand related data. Unlike `list_user_messages`, which fetches a collection of emails with advanced filtering, this function is designed to retrieve a single, known message. |
-| `user_delete_message` | Permanently deletes a specific email, identified by `message_id`, from a user's mailbox. If `user_id` is not provided, it defaults to the current authenticated user. Unlike retrieval functions such as `get_user_message`, this performs a destructive action to remove the specified email from Outlook. |
-| `list_message_attachments` | Retrieves attachments for a specific email message, identified by its ID. Supports advanced querying for filtering, sorting, and pagination, allowing users to select specific fields to return in the result set, focusing only on attachments rather than the full message content. |
-| `get_current_user_profile` | Fetches the `userPrincipalName` for the currently authenticated user from the `/me` endpoint. This internal helper is used by other methods to automatically obtain the user's ID for API calls when a `user_id` is not explicitly provided. |
-| `get_next_page` | Executes a GET request for a full URL, typically the `@odata.nextLink` from a previous paginated API response. It simplifies retrieving subsequent pages of data from list functions by handling URL validation and parsing before fetching the results for the next page. |
+| `reply_to_email` | Replies to a specific email message. |
+| `send_email` | Sends a new email. |
+| `get_email_folder` | Retrieves a specific email folder's metadata by its ID. |
+| `list_emails` | Retrieves a list of emails from a user's mailbox. |
+| `get_email` | Retrieves a specific email by its ID. |
+| `delete_email` | Permanently deletes a specific email by its ID. |
+| `list_email_attachments` | Retrieves attachments for a specific email. |
+| `get_attachment` | Retrieves a specific attachment from an email message and formats it as a dictionary. |
+| `get_my_profile` | Fetches the userPrincipalName for the currently authenticated user. |
+| `get_next_page_results` | Retrieves the next page of results from a paginated API response. |
+| `list_calendars` | Retrieves a list of calendars for the user. |
+| `get_calendar` | Retrieves a specific calendar by its ID. |
+| `create_calendar` | Creates a new calendar for the user. |
+| `update_calendar` | Updates an existing calendar's name. |
+| `delete_calendar` | Deletes a specific calendar. |
+| `list_events` | Retrieves a list of events from a calendar or the user's default calendar. |
+| `get_event` | Retrieves a specific event by its ID. |
+| `create_event` | Creates a new event in a calendar. |
+| `update_event` | Updates an existing event. |
+| `delete_event` | Deletes a specific event. |
+| `list_calendar_view` | Retrieves events between a start and end time (includes expanded recurring events). |
+| `get_schedule` | Retrieves free/busy information for a set of users, groups, or resources. |