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

universal_mcp/applications/domain_checker/app.py

@@ -1,42 +1,18 @@
 import logging
 import sys
 from typing import Any
-
 import dns.resolver
 import requests
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 
-# Configure logging
 logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[logging.StreamHandler(sys.stderr)],
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", handlers=[logging.StreamHandler(sys.stderr)]
 )
-
 logger = logging.getLogger("domain_checker")
-
-# Constants
 RDAP_BOOTSTRAP_URL = "https://data.iana.org/rdap/dns.json"
 USER_AGENT = "DomainCheckerBot/1.0"
-
-# Top TLDs to check
-TOP_TLDS = [
-    "com",
-    "net",
-    "org",
-    "io",
-    "co",
-    "app",
-    "dev",
-    "ai",
-    "me",
-    "info",
-    "xyz",
-    "online",
-    "site",
-    "tech",
-]
+TOP_TLDS = ["com", "net", "org", "io", "co", "app", "dev", "ai", "me", "info", "xyz", "online", "site", "tech"]
 
 
 class DomainCheckerApp(APIApplication):
@@ -52,22 +28,16 @@ class DomainCheckerApp(APIApplication):
         Fetches a domain's registration details from Registration Data Access Protocol (RDAP) servers. It dynamically selects the appropriate server URL based on the domain's TLD, with special handling for common ones. Returns the JSON data as a dictionary or None if the request fails or data is unavailable.
         """
         try:
-            # Special case for .ch and .li domains
             tld = domain.split(".")[-1].lower()
             if tld in ["ch", "li"]:
                 rdap_url = f"https://rdap.nic.{tld}/domain/{domain}"
-            # Use common RDAP servers for known TLDs
             elif tld in ["com", "net"]:
                 rdap_url = f"https://rdap.verisign.com/{tld}/v1/domain/{domain}"
             elif tld == "org":
-                rdap_url = (
-                    f"https://rdap.publicinterestregistry.org/rdap/domain/{domain}"
-                )
+                rdap_url = f"https://rdap.publicinterestregistry.org/rdap/domain/{domain}"
             else:
                 rdap_url = f"https://rdap.org/domain/{domain}"
-
             headers = {"Accept": "application/rdap+json", "User-Agent": USER_AGENT}
-
             response = requests.get(rdap_url, headers=headers, timeout=5)
             if response.status_code == 200:
                 return response.json()
@@ -122,21 +92,13 @@ class DomainCheckerApp(APIApplication):
             domain, availability, registration, dns, rdap, important
         """
         logger.info(f"Checking domain: {domain}")
-
-        # First check DNS
         has_dns = await self._check_dns(domain)
-
         if has_dns:
-            # Domain exists, get RDAP data if possible
             rdap_data = await self._get_rdap_data(domain)
-
             if rdap_data:
-                # Extract data from RDAP
                 registrar = "Unknown"
                 reg_date = "Unknown"
                 exp_date = "Unknown"
-
-                # Extract registrar
                 entities = rdap_data.get("entities", [])
                 for entity in entities:
                     if "registrar" in entity.get("roles", []):
@@ -146,15 +108,12 @@ class DomainCheckerApp(APIApplication):
                                 if entry[0] in ["fn", "org"] and len(entry) > 3:
                                     registrar = entry[3]
                                     break
-
-                # Extract dates
                 events = rdap_data.get("events", [])
                 for event in events:
                     if event.get("eventAction") == "registration":
                         reg_date = event.get("eventDate", "Unknown")
                     elif event.get("eventAction") == "expiration":
                         exp_date = event.get("eventDate", "Unknown")
-
                 return {
                     "domain": domain,
                     "status": "Registered",
@@ -175,8 +134,6 @@ class DomainCheckerApp(APIApplication):
                     "rdap_data_available": False,
                     "note": "Domain has DNS records but RDAP data couldn't be retrieved",
                 }
-
-        # Try RDAP one more time even if DNS not found
         rdap_data = await self._get_rdap_data(domain)
         if rdap_data:
             return {
@@ -189,8 +146,6 @@ class DomainCheckerApp(APIApplication):
                 "rdap_data_available": True,
                 "note": "Domain found in RDAP registry",
             }
-
-        # If we get here, the domain is likely available
         return {
             "domain": domain,
             "status": "Available",
@@ -233,17 +188,12 @@ class DomainCheckerApp(APIApplication):
             tld, keyword, domain-search, availability, bulk-check, important
         """
         logger.info(f"Checking keyword: {keyword} across TLDs")
-
         available = []
         taken = []
-
-        # Check each TLD in sequence
         for tld in TOP_TLDS:
             domain = f"{keyword}.{tld}"
             has_dns = await self._check_dns(domain)
-
             if not has_dns:
-                # Double-check with RDAP if no DNS
                 rdap_data = await self._get_rdap_data(domain)
                 if not rdap_data:
                     available.append(domain)
@@ -251,7 +201,6 @@ class DomainCheckerApp(APIApplication):
                     taken.append(domain)
             else:
                 taken.append(domain)
-
         return {
             "keyword": keyword,
             "tlds_checked": len(TOP_TLDS),

universal_mcp/applications/e2b/app.py

@@ -1,17 +1,12 @@
 import os
 from typing import Annotated, Any
-
 from loguru import logger
 
 try:
     from e2b_code_interpreter import Sandbox
-
 except ImportError:
     Sandbox = None
-    logger.error(
-        "Failed to import E2B Sandbox. Please ensure 'e2b_code_interpreter' is installed."
-    )
-
+    logger.error("Failed to import E2B Sandbox. Please ensure 'e2b_code_interpreter' is installed.")
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.exceptions import NotAuthorizedError, ToolError
 from universal_mcp.integrations import Integration
@@ -28,9 +23,7 @@ class E2bApp(APIApplication):
         super().__init__(name="e2b", integration=integration, **kwargs)
         self._e2b_api_key: str | None = None
         if Sandbox is None:
-            logger.warning(
-                "E2B Sandbox SDK is not available. E2B tools will not function."
-            )
+            logger.warning("E2B Sandbox SDK is not available. E2B tools will not function.")
 
     @property
     def e2b_api_key(self) -> str:
@@ -40,54 +33,31 @@ class E2bApp(APIApplication):
         if self._e2b_api_key is None:
             if not self.integration:
                 logger.error("E2B App: Integration not configured.")
-                raise NotAuthorizedError(
-                    "Integration not configured for E2B App. Cannot retrieve API key."
-                )
-
+                raise NotAuthorizedError("Integration not configured for E2B App. Cannot retrieve API key.")
             try:
                 credentials = self.integration.get_credentials()
             except NotAuthorizedError as e:
-                logger.error(
-                    f"E2B App: Authorization error when fetching credentials: {e.message}"
-                )
-                raise  # Re-raise the original NotAuthorizedError
+                logger.error(f"E2B App: Authorization error when fetching credentials: {e.message}")
+                raise
             except Exception as e:
-                logger.error(
-                    f"E2B App: Unexpected error when fetching credentials: {e}",
-                    exc_info=True,
-                )
+                logger.error(f"E2B App: Unexpected error when fetching credentials: {e}", exc_info=True)
                 raise NotAuthorizedError(f"Failed to get E2B credentials: {e}")
-
-            api_key = (
-                credentials.get("api_key")
-                or credentials.get("API_KEY")  # Check common variations
-                or credentials.get("apiKey")
-            )
-
+            api_key = credentials.get("api_key") or credentials.get("API_KEY") or credentials.get("apiKey")
             if not api_key:
                 logger.error("E2B App: API key not found in credentials.")
                 action_message = "API key for E2B is missing. Please ensure it's set in the store via MCP frontend or configuration."
-                if hasattr(self.integration, "authorize") and callable(
-                    self.integration.authorize
-                ):
+                if hasattr(self.integration, "authorize") and callable(self.integration.authorize):
                     try:
                         auth_details = self.integration.authorize()
                         if isinstance(auth_details, str):
                             action_message = auth_details
                         elif isinstance(auth_details, dict) and "url" in auth_details:
-                            action_message = (
-                                f"Please authorize via: {auth_details['url']}"
-                            )
-                        elif (
-                            isinstance(auth_details, dict) and "message" in auth_details
-                        ):
+                            action_message = f"Please authorize via: {auth_details['url']}"
+                        elif isinstance(auth_details, dict) and "message" in auth_details:
                             action_message = auth_details["message"]
                     except Exception as auth_e:
-                        logger.warning(
-                            f"Could not retrieve specific authorization action for E2B: {auth_e}"
-                        )
+                        logger.warning(f"Could not retrieve specific authorization action for E2B: {auth_e}")
                 raise NotAuthorizedError(action_message)
-
             self._e2b_api_key = api_key
             logger.info("E2B API Key successfully retrieved and cached.")
         return self._e2b_api_key
@@ -95,40 +65,28 @@ class E2bApp(APIApplication):
     def _format_execution_output(self, execution: Any) -> str:
         """Helper function to format the E2B execution logs nicely."""
         output_parts = []
-
         try:
             logs = getattr(execution, "logs", None)
-
             if logs is not None:
-                # Collect stdout
                 if getattr(logs, "stdout", None):
                     stdout_content = "".join(logs.stdout).strip()
                     if stdout_content:
                         output_parts.append(stdout_content)
-
-                # Collect stderr
                 if getattr(logs, "stderr", None):
                     stderr_content = "".join(logs.stderr).strip()
                     if stderr_content:
                         output_parts.append(f"--- ERROR ---\n{stderr_content}")
-
-            # Fallback: check execution.text (covers expressions returning values)
             if not output_parts and hasattr(execution, "text"):
                 text_content = str(execution.text).strip()
                 if text_content:
                     output_parts.append(text_content)
-
         except Exception as e:
             output_parts.append(f"Failed to format execution output: {e}")
-
         if not output_parts:
             return "Execution finished with no output (stdout/stderr)."
-
         return "\n\n".join(output_parts)
 
-    def execute_python_code(
-        self, code: Annotated[str, "The Python code to execute."]
-    ) -> str:
+    async def execute_python_code(self, code: Annotated[str, "The Python code to execute."]) -> str:
         """
         Executes a Python code string in a secure E2B sandbox. It authenticates using the configured API key, runs the code, and returns a formatted string containing the execution's output (stdout/stderr). It raises specific exceptions for authorization failures or general execution issues.
 
@@ -151,7 +109,6 @@ class E2bApp(APIApplication):
             raise ToolError("E2B Sandbox SDK (e2b_code_interpreter) is not installed.")
         if not code or not isinstance(code, str):
             raise ValueError("Provided code must be a non-empty string.")
-
         try:
             logger.info("Attempting to execute Python code in E2B Sandbox.")
             os.environ["E2B_API_KEY"] = self.e2b_api_key
@@ -164,17 +121,10 @@ class E2bApp(APIApplication):
         except Exception as e:
             logger.exception("E2B code execution failed.")
             lower = str(e).lower()
-            if (
-                "authentication" in lower
-                or "api key" in lower
-                or "401" in lower
-                or "403" in lower
-            ):
+            if "authentication" in lower or "api key" in lower or "401" in lower or ("403" in lower):
                 raise NotAuthorizedError(f"E2B authentication/permission failed: {e}")
             raise ToolError(f"E2B code execution failed: {e}")
 
     def list_tools(self) -> list[callable]:
         """Lists the tools available from the E2bApp."""
-        return [
-            self.execute_python_code,
-        ]
+        return [self.execute_python_code]

universal_mcp/applications/elevenlabs/app.py

@@ -1,11 +1,9 @@
 import uuid
 from io import BytesIO
-
 import requests
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.exceptions import NotAuthorizedError
 from universal_mcp.integrations import Integration
-
 from elevenlabs import ElevenLabs
 from universal_mcp.applications.file_system.app import FileSystemApp
 
@@ -24,24 +22,14 @@ class ElevenlabsApp(APIApplication):
             credentials = self.integration.get_credentials()
             if not credentials:
                 raise NotAuthorizedError("No credentials found")
-            api_key = (
-                credentials.get("api_key")
-                or credentials.get("API_KEY")
-                or credentials.get("apiKey")
-            )
+            api_key = credentials.get("api_key") or credentials.get("API_KEY") or credentials.get("apiKey")
             if not api_key:
                 raise NotAuthorizedError("No api key found")
             self._client = ElevenLabs(api_key=api_key)
         return self._client
 
-    # def get_voices(self):
-    #     return self.client.voices.list_voices()
-
     async def generate_speech_audio_url(
-        self,
-        text: str,
-        voice_id: str = "21m00Tcm4TlvDq8ikWAM",
-        model_id: str = "eleven_multilingual_v2",
+        self, text: str, voice_id: str = "21m00Tcm4TlvDq8ikWAM", model_id: str = "eleven_multilingual_v2"
     ) -> bytes:
         """
         Converts a text string into speech using the ElevenLabs API. The function then saves the generated audio to a temporary MP3 file and returns a public URL to access it, rather than the raw audio bytes.
@@ -59,26 +47,14 @@ class ElevenlabsApp(APIApplication):
         Tags:
             important
         """
-        audio_generator = self.client.text_to_speech.convert(
-            text=text,
-            voice_id=voice_id,
-            model_id=model_id,
-            output_format="mp3_44100_128",
-        )
-
-        # Collect all audio chunks from the generator
+        audio_generator = self.client.text_to_speech.convert(text=text, voice_id=voice_id, model_id=model_id, output_format="mp3_44100_128")
         audio_data = b""
         for chunk in audio_generator:
             audio_data += chunk
-
-        upload_result = await FileSystemApp.write_file(
-            audio_data, f"/tmp/{uuid.uuid4()}.mp3"
-        )
+        upload_result = await FileSystemApp.write_file(audio_data, f"/tmp/{uuid.uuid4()}.mp3")
         return upload_result["data"]["url"]
 
-    async def speech_to_text(
-        self, audio_file_path: str, language_code: str = "eng", diarize: bool = True
-    ) -> str:
+    async def speech_to_text(self, audio_file_path: str, language_code: str = "eng", diarize: bool = True) -> str:
         """
         Transcribes an audio file into text using the ElevenLabs API. It supports language specification and speaker diarization, providing the inverse operation to the audio-generating `text_to_speech` method. Note: The docstring indicates this is a placeholder for an undocumented endpoint.
 
@@ -92,19 +68,12 @@ class ElevenlabsApp(APIApplication):
             important
         """
         transcription = self.client.speech_to_text.convert(
-            file=audio_file_path,
-            model_id="scribe_v1",  # Model to use, for now only "scribe_v1" is supported
-            tag_audio_events=True,  # Tag audio events like laughter, applause, etc.
-            language_code=language_code,  # Language of the audio file. If set to None, the model will detect the language automatically.
-            diarize=diarize,  # Whether to annotate who is speaking
+            file=audio_file_path, model_id="scribe_v1", tag_audio_events=True, language_code=language_code, diarize=diarize
         )
         return transcription
 
     async def speech_to_speech(
-        self,
-        audio_url: str,
-        voice_id: str = "21m00Tcm4TlvDq8ikWAM",
-        model_id: str = "eleven_multilingual_sts_v2",
+        self, audio_url: str, voice_id: str = "21m00Tcm4TlvDq8ikWAM", model_id: str = "eleven_multilingual_sts_v2"
     ) -> bytes:
         """
         Downloads an audio file from a URL and converts the speech into a specified target voice using the ElevenLabs API. This function transforms the speaker's voice in an existing recording and returns the new audio data as bytes, distinct from creating audio from text.
@@ -123,19 +92,12 @@ class ElevenlabsApp(APIApplication):
         response = requests.get(audio_url)
         audio_data = BytesIO(response.content)
         response = self.client.speech_to_speech.convert(
-            voice_id=voice_id,
-            audio=audio_data,
-            model_id=model_id,
-            output_format="mp3_44100_128",
+            voice_id=voice_id, audio=audio_data, model_id=model_id, output_format="mp3_44100_128"
         )
         return response.content
 
     def list_tools(self):
-        return [
-            self.generate_speech_audio_url,
-            self.speech_to_text,
-            self.speech_to_speech,
-        ]
+        return [self.generate_speech_audio_url, self.speech_to_text, self.speech_to_speech]
 
 
 async def demo_text_to_speech():

universal_mcp/applications/exa/README.md

@@ -9,7 +9,11 @@ This is automatically generated from OpenAPI schema for the ExaApp API.
 
 | Tool | Description |
 |------|-------------|
-| `search_with_filters` | Executes a query against the Exa API's `/search` endpoint, returning a list of results. This function supports extensive filtering by search type, category, domains, publication dates, and specific text content to refine the search query and tailor the API's response. |
-| `find_similar_by_url` | Finds web pages semantically similar to a given URL. Unlike the `search` function, which uses a text query, this method takes a specific link and returns a list of related results, with options to filter by domain, publication date, and content. |
-| `fetch_page_content` | Retrieves and processes content from a list of URLs, returning full text, summaries, or highlights. Unlike the search function which finds links, this function fetches the actual page content, with optional support for live crawling to get the most up-to-date information. |
-| `answer` | Retrieves a direct, synthesized answer for a given query by calling the Exa `/answer` API endpoint. Unlike `search`, which returns web results, this function provides a conclusive response. It supports streaming, including source text, and selecting a search model. |
+| `search` | Performs a semantic or keyword search across the web and returns ranked results. |
+| `find_similar` | Retrieves webpages that are semantically similar to a provided URL. |
+| `get_contents` | Deep-fetches the actual content of specific URLs or Result IDs. |
+| `answer` | Synthesizes a direct, objective answer to a research question based on multiple web sources. |
+| `create_research_task` | Initiates a long-running, autonomous research task that explores the web to fulfill complex instructions. |
+| `get_research_task` | Retrieves the current status, metadata, and (if finished) final results of a research task. |
+| `poll_research_task` | Blocks until a research task completes, fails, or times out. |
+| `list_research_tasks` | Provides a paginated list of all past and current research tasks for auditing or recovery. |