universal-mcp-applications 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

universal_mcp/applications/domain_checker/app.py

@@ -48,8 +48,10 @@ class DomainCheckerApp(APIApplication):
     def __init__(self, integration: Integration = None, **kwargs) -> None:
         super().__init__(name="domain_checker", integration=integration, **kwargs)
 
-    async def get_rdap_data(self, domain: str) -> dict[str, Any] | None:
-        """Get RDAP data for a domain"""
+    async def _get_rdap_data(self, domain: str) -> dict[str, Any] | None:
+        """
+        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()
@@ -75,8 +77,10 @@ class DomainCheckerApp(APIApplication):
             logger.error(f"RDAP error for {domain}: {e}")
             return None
 
-    async def check_dns(self, domain: str) -> bool:
-        """Check if a domain has DNS records"""
+    async def _check_dns(self, domain: str) -> bool:
+        """
+        Performs a DNS lookup for a domain, checking first for an 'A' record and then an 'NS' record. It returns true if either record type exists, serving as a quick preliminary check to determine if a domain is actively configured on the internet.
+        """
         try:
             dns.resolver.resolve(domain, "A")
             return True
@@ -87,18 +91,18 @@ class DomainCheckerApp(APIApplication):
             except:
                 return False
 
-    async def check_domain_tool(self, domain: str) -> dict[str, Any]:
+    async def check_domain_registration(self, domain: str) -> dict[str, Any]:
         """
-        Checks if a domain is available for registration by querying DNS records and RDAP data.
-
+        Determines a domain's availability by querying DNS and RDAP servers. For registered domains, it returns details like registrar and key dates. This function provides a comprehensive analysis for a single, fully qualified domain name, unlike `check_keyword_across_tlds_tool` which checks a keyword across multiple domains.
+        
         This method performs a comprehensive domain availability check by first checking DNS records
         and then querying RDAP (Registration Data Access Protocol) servers for detailed registration
         information. It provides detailed information about registered domains including registrar,
         registration date, and expiration date.
-
+        
         Args:
             domain: String representing the domain name to check (e.g., "example.com")
-
+        
         Returns:
             Dictionary containing domain availability information with the following keys:
             - domain: The domain name that was checked
@@ -109,23 +113,23 @@ class DomainCheckerApp(APIApplication):
             - has_dns: Boolean indicating if DNS records exist
             - rdap_data_available: Boolean indicating if RDAP data was retrieved
             - note: Additional information when needed
-
+        
         Raises:
             DNSException: When DNS resolution fails due to network issues or invalid domain format
             RequestException: When RDAP queries fail due to network issues or server errors
             ValueError: When the domain parameter is empty or contains invalid characters
-
+        
         Tags:
             domain, availability, registration, dns, rdap, important
         """
         logger.info(f"Checking domain: {domain}")
 
         # First check DNS
-        has_dns = await self.check_dns(domain)
+        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)
+            rdap_data = await self._get_rdap_data(domain)
 
             if rdap_data:
                 # Extract data from RDAP
@@ -174,7 +178,7 @@ class DomainCheckerApp(APIApplication):
                 }
 
         # Try RDAP one more time even if DNS not found
-        rdap_data = await self.get_rdap_data(domain)
+        rdap_data = await self._get_rdap_data(domain)
         if rdap_data:
             return {
                 "domain": domain,
@@ -199,18 +203,18 @@ class DomainCheckerApp(APIApplication):
             "note": "No DNS records or RDAP data found",
         }
 
-    async def check_tlds_tool(self, keyword: str) -> dict[str, Any]:
+    async def find_available_domains_for_keyword(self, keyword: str) -> dict[str, Any]:
         """
-        Checks a keyword across multiple top-level domains (TLDs) to find available domain names.
-
+        Checks a keyword's availability across a predefined list of popular TLDs. Using DNS and RDAP lookups, it generates a summary report of available and taken domains. This bulk-check differs from `check_domain_registration`, which deeply analyzes a single, fully-qualified domain.
+        
         This method systematically checks a given keyword across 14 popular TLDs including .com, .net,
         .org, .io, .co, .app, .dev, .ai, .me, .info, .xyz, .online, .site, and .tech. It performs
         DNS lookups and RDAP queries to determine domain availability and provides a comprehensive
         report of available and taken domains.
-
+        
         Args:
             keyword: String representing the keyword to check across TLDs (e.g., "myapp")
-
+        
         Returns:
             Dictionary containing TLD availability information with the following keys:
             - keyword: The keyword that was checked
@@ -220,12 +224,12 @@ class DomainCheckerApp(APIApplication):
             - available_domains: List of available domain names
             - taken_domains: List of taken domain names
             - tlds_checked_list: Complete list of TLDs that were checked
-
+        
         Raises:
             DNSException: When DNS resolution fails due to network issues or invalid domain format
             RequestException: When RDAP queries fail due to network issues or server errors
             ValueError: When the keyword parameter is empty or contains invalid characters
-
+        
         Tags:
             tld, keyword, domain-search, availability, bulk-check, important
         """
@@ -237,11 +241,11 @@ class DomainCheckerApp(APIApplication):
         # Check each TLD in sequence
         for tld in TOP_TLDS:
             domain = f"{keyword}.{tld}"
-            has_dns = await self.check_dns(domain)
+            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)
+                rdap_data = await self._get_rdap_data(domain)
                 if not rdap_data:
                     available.append(domain)
                 else:
@@ -263,4 +267,7 @@ class DomainCheckerApp(APIApplication):
         """
         Lists the available tools (methods) for this application.
         """
-        return [self.check_domain_tool, self.check_tlds_tool]
+        return [
+            self.check_domain_registration, 
+            self.find_available_domains_for_keyword
+            ]

universal_mcp/applications/e2b/app.py

@@ -35,8 +35,7 @@ class E2bApp(APIApplication):
     @property
     def e2b_api_key(self) -> str:
         """
-        Retrieves and caches the E2B API key from the integration.
-        Raises NotAuthorizedError if the key cannot be obtained.
+        A property that lazily retrieves and caches the E2B API key from the configured integration. It fetches the key on the first call, handles authentication failures, and raises `NotAuthorizedError` with actionable guidance if the key cannot be obtained.
         """
         if self._e2b_api_key is None:
             if not self.integration:
@@ -131,20 +130,20 @@ class E2bApp(APIApplication):
         self, code: Annotated[str, "The Python code to execute."]
     ) -> str:
         """
-        Executes Python code in a sandbox environment and returns the formatted output.
-
+        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.
+        
         Args:
             code: String containing the Python code to be executed in the sandbox.
-
+        
         Returns:
             A string containing the formatted execution output/logs from running the code.
-
+        
         Raises:
             ToolError: When there are issues with sandbox initialization or code execution,
                        or if the E2B SDK is not installed.
             NotAuthorizedError: When API key authentication fails during sandbox setup.
             ValueError: When provided code string is empty or invalid.
-
+        
         Tags:
             execute, sandbox, code-execution, security, important
         """

universal_mcp/applications/elevenlabs/app.py

@@ -17,11 +17,14 @@ class ElevenlabsApp(APIApplication):
 
     @property
     def client(self) -> ElevenLabs:
+        """
+        A property that lazily initializes and returns an authenticated `ElevenLabs` SDK client. On first access, it retrieves the API key from integration credentials and caches the instance, raising a `NotAuthorizedError` if credentials are not found.
+        """
         if self._client is None:
-            # credentials = self.integration.get_credentials()
-            # if not credentials:
-            #     raise NotAuthorizedError("No credentials found")
-            api_key = "sk_50d565b590e5fecff99c12393b2ed7bc5d3dcb74a1fa6a68"  # credentials.get("api_key") or credentials.get("API_KEY") or credentials.get("apiKey")
+            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")
             if not api_key:
                 raise NotAuthorizedError("No api key found")
             self._client = ElevenLabs(api_key=api_key)
@@ -30,22 +33,22 @@ class ElevenlabsApp(APIApplication):
     # def get_voices(self):
     #     return self.client.voices.list_voices()
 
-    async def text_to_speech(
+    async def generate_speech_audio_url(
         self,
         text: str,
         voice_id: str = "21m00Tcm4TlvDq8ikWAM",
         model_id: str = "eleven_multilingual_v2",
     ) -> bytes:
         """
-        Converts text to speech using a specified voice.
-
+        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.
+        
         Args:
             text (str): The text to convert to speech.
             voice_id (str): The ID of the voice to use.
             model_id (str, optional): The model to use. Defaults to "eleven_multilingual_v2".
             stability (float, optional): The stability of the voice.
             similarity_boost (float, optional): The similarity boost of the voice.
-
+        
         Returns:
             bytes: The audio data.
             
@@ -73,13 +76,11 @@ class ElevenlabsApp(APIApplication):
         self, audio_file_path: str, language_code: str = "eng", diarize: bool = True
     ) -> str:
         """
-        Converts speech to text.
-        NOTE: The REST API endpoint for this functionality is not yet publicly documented.
-        This is a placeholder and will not work until the endpoint is available.
-
+        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.
+        
         Args:
             audio_file_path (str): The path to the audio file.
-
+        
         Returns:
             str: The transcribed text.
             
@@ -102,13 +103,13 @@ class ElevenlabsApp(APIApplication):
         model_id: str = "eleven_multilingual_sts_v2",
     ) -> bytes:
         """
-        Changes the voice in an audio file to a different voice.
-
+        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.
+        
         Args:
             voice_id (str): The ID of the voice to use for the conversion.
             audio_file_path (str): The path to the audio file to transform.
             model_id (str, optional): The model to use. Defaults to "eleven_multilingual_sts_v2".
-
+        
         Returns:
             bytes: The transformed audio data.
             
@@ -127,19 +128,22 @@ class ElevenlabsApp(APIApplication):
 
     def list_tools(self):
         return [
-            self.text_to_speech,
+            self.generate_speech_audio_url,
             self.speech_to_text,
             self.speech_to_speech,
         ]
 
 
-async def test_elevenlabs():
+async def demo_text_to_speech():
+    """
+    A demonstration function that instantiates the `ElevenlabsApp` to test its `text_to_speech` method. It converts a sample string to audio and prints the resulting file URL to the console, serving as a basic usage example when the script is executed directly.
+    """
     app = ElevenlabsApp()
-    audio = await app.text_to_speech("Hello, world!")
+    audio = await app.generate_speech_audio_url("Hello, world!")
     print(audio)
 
 
 if __name__ == "__main__":
     import asyncio
 
-    asyncio.run(test_elevenlabs())
+    asyncio.run(demo_text_to_speech())

universal_mcp/applications/exa/app.py

@@ -9,7 +9,7 @@ class ExaApp(APIApplication):
         super().__init__(name="exa", integration=integration, **kwargs)
         self.base_url = "https://api.exa.ai"
 
-    def search(
+    def search_with_filters(
         self,
         query,
         useAutoprompt=None,
@@ -27,8 +27,8 @@ class ExaApp(APIApplication):
         contents=None,
     ) -> dict[str, Any]:
         """
-        Searches for data using the specified criteria and returns a list of results.
-
+        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.
+        
         Args:
             query (string): The query string for the search. Example: 'Latest developments in LLM capabilities'.
             useAutoprompt (boolean): Autoprompt converts your query to an Exa-style query. Enabled by default for auto search, optional for neural search, and not available for keyword search. Example: 'True'.
@@ -44,10 +44,10 @@ class ExaApp(APIApplication):
             includeText (array): List of strings that must be present in webpage text of results. Currently, only 1 string is supported, of up to 5 words. Example: "['large language model']".
             excludeText (array): List of strings that must not be present in webpage text of results. Currently, only 1 string is supported, of up to 5 words. Example: "['course']".
             contents (object): contents
-
+        
         Returns:
             dict[str, Any]: OK
-
+        
         Tags:
             important
         """
@@ -74,7 +74,7 @@ class ExaApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def find_similar(
+    def find_similar_by_url(
         self,
         url,
         numResults=None,
@@ -89,8 +89,8 @@ class ExaApp(APIApplication):
         contents=None,
     ) -> dict[str, Any]:
         """
-        Finds and returns similar items using the API at "/findSimilar" via the POST method.
-
+        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.
+        
         Args:
             url (string): The url for which you would like to find similar links. Example: 'https://arxiv.org/abs/2307.06435'.
             numResults (integer): Number of results to return (up to thousands of results available for custom plans) Example: '10'.
@@ -103,10 +103,10 @@ class ExaApp(APIApplication):
             includeText (array): List of strings that must be present in webpage text of results. Currently, only 1 string is supported, of up to 5 words. Example: "['large language model']".
             excludeText (array): List of strings that must not be present in webpage text of results. Currently, only 1 string is supported, of up to 5 words. Example: "['course']".
             contents (object): contents
-
+        
         Returns:
             dict[str, Any]: OK
-
+        
         Tags:
             important
         """
@@ -130,7 +130,7 @@ class ExaApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def get_contents(
+    def fetch_page_content(
         self,
         urls,
         ids=None,
@@ -144,8 +144,8 @@ class ExaApp(APIApplication):
         extras=None,
     ) -> dict[str, Any]:
         """
-        Creates new content entries via a POST request to the "/contents" endpoint.
-
+        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.
+        
         Args:
             urls (array): Array of URLs to crawl (backwards compatible with 'ids' parameter). Example: "['https://arxiv.org/pdf/2307.06435']".
             ids (array): Deprecated - use 'urls' instead. Array of document IDs obtained from searches. Example: "['https://arxiv.org/pdf/2307.06435']".
@@ -162,10 +162,10 @@ class ExaApp(APIApplication):
             subpages (integer): The number of subpages to crawl. The actual number crawled may be limited by system constraints. Example: '1'.
             subpageTarget (string): Keyword to find specific subpages of search results. Can be a single string or an array of strings, comma delimited. Example: 'sources'.
             extras (object): Extra parameters to pass.
-
+        
         Returns:
             dict[str, Any]: OK
-
+        
         Tags:
             important
         """
@@ -190,17 +190,17 @@ class ExaApp(APIApplication):
 
     def answer(self, query, stream=None, text=None, model=None) -> dict[str, Any]:
         """
-        Provides an answer to a query using the API endpoint at "/answer" via the POST method.
-
+        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.
+        
         Args:
             query (string): The question or query to answer. Example: 'What is the latest valuation of SpaceX?'.
             stream (boolean): If true, the response is returned as a server-sent events (SSS) stream.
             text (boolean): If true, the response includes full text content in the search results
             model (string): The search model to use for the answer. Exa passes only one query to exa, while exa-pro also passes 2 expanded queries to our search model.
-
+        
         Returns:
             dict[str, Any]: OK
-
+        
         Tags:
             important
         """
@@ -218,4 +218,9 @@ class ExaApp(APIApplication):
         return response.json()
 
     def list_tools(self):
-        return [self.search, self.find_similar, self.get_contents, self.answer]
+        return [
+            self.search_with_filters, 
+            self.find_similar_by_url, 
+            self.fetch_page_content, 
+            self.answer
+            ]

universal_mcp/applications/falai/app.py

@@ -28,6 +28,9 @@ class FalaiApp(APIApplication):
 
     @property
     def fal_client(self) -> AsyncClient:
+        """
+        A cached property that lazily initializes an `AsyncClient` instance for API communication. It retrieves the API key from the configured integration, centralizing authentication for all Fal AI operations. Raises `NotAuthorizedError` if the key is missing.
+        """
         if self._fal_client is None:
             credentials = self.integration.get_credentials()
             logger.info(f"Credentials: {credentials}")
@@ -55,21 +58,21 @@ class FalaiApp(APIApplication):
         hint: str | None = None,
     ) -> Any:
         """
-        Run a Fal AI application directly and wait for the result. Suitable for short-running applications with synchronous execution from the caller's perspective.
-
+        Executes a Fal AI application synchronously, waiting for completion and returning the result directly. This method is suited for short-running tasks, unlike `submit` which queues a job for asynchronous processing and returns a request ID instead of the final output.
+        
         Args:
             arguments: A dictionary of arguments for the application
             application: The name or ID of the Fal application (defaults to 'fal-ai/flux/dev')
             path: Optional subpath for the application endpoint
             timeout: Optional timeout in seconds for the request
             hint: Optional hint for runner selection
-
+        
         Returns:
             The result of the application execution as a Python object (converted from JSON response)
-
+        
         Raises:
             ToolError: Raised when the Fal API request fails, wrapping the original exception
-
+        
         Tags:
             run, execute, ai, synchronous, fal, important
         """
@@ -98,8 +101,8 @@ class FalaiApp(APIApplication):
         priority: Priority | None = None,
     ) -> str:
         """
-        Submits a request to the Fal AI queue for asynchronous processing and returns a request ID for tracking the job.
-
+        Submits a job to the Fal AI queue for asynchronous processing. It immediately returns a unique request ID for tracking the job's lifecycle with the `status`, `result`, and `cancel` methods. Unlike the synchronous `run` method, this function does not wait for the job's completion.
+        
         Args:
             arguments: A dictionary of arguments for the application
             application: The name or ID of the Fal application, defaulting to 'fal-ai/flux/dev'
@@ -107,13 +110,13 @@ class FalaiApp(APIApplication):
             hint: Optional hint for runner selection
             webhook_url: Optional URL to receive a webhook when the request completes
             priority: Optional queue priority ('normal' or 'low')
-
+        
         Returns:
             The request ID (str) of the submitted asynchronous job
-
+        
         Raises:
             ToolError: Raised when the Fal API request fails, wrapping the original exception
-
+        
         Tags:
             submit, async_job, start, ai, queue
         """
@@ -136,26 +139,26 @@ class FalaiApp(APIApplication):
                 f"Failed to submit Fal application {application}: {e}"
             ) from e
 
-    async def status(
+    async def check_status(
         self,
         request_id: str,
         application: str = "fal-ai/flux/dev",
         with_logs: bool = False,
     ) -> Status:
         """
-        Checks the status of a previously submitted Fal AI request and retrieves its current execution state
-
+        Checks the execution state (e.g., Queued, InProgress) of an asynchronous Fal AI job using its request ID. It provides a non-blocking way to monitor jobs initiated via `submit` without fetching the final `result`, and can optionally include logs.
+        
         Args:
             request_id: The unique identifier of the submitted request, obtained from a previous submit operation
             application: The name or ID of the Fal application (defaults to 'fal-ai/flux/dev')
             with_logs: Boolean flag to include execution logs in the status response (defaults to False)
-
+        
         Returns:
             A Status object containing the current state of the request (Queued, InProgress, or Completed)
-
+        
         Raises:
             ToolError: Raised when the Fal API request fails or when the provided request ID is invalid
-
+        
         Tags:
             status, check, async_job, monitoring, ai
         """
@@ -174,22 +177,22 @@ class FalaiApp(APIApplication):
                 f"Failed to get status for Fal request_id {request_id}: {e}"
             ) from e
 
-    async def result(
+    async def get_result(
         self, request_id: str, application: str = "fal-ai/flux/dev"
     ) -> Any:
         """
-        Retrieves the result of a completed Fal AI request, waiting for completion if the request is still running.
-
+        Fetches the final output for an asynchronous job, identified by its request_id. This function blocks execution, waiting for the job initiated by `submit` to complete before returning the result. It complements the non-blocking `status` check by providing a synchronous way to get a completed job's data.
+        
         Args:
             request_id: The unique identifier of the submitted request
             application: The name or ID of the Fal application (defaults to 'fal-ai/flux/dev')
-
+        
         Returns:
             The result of the application execution, converted from JSON response to Python data structures (dict/list)
-
+        
         Raises:
             ToolError: When the Fal API request fails or the request does not complete successfully
-
+        
         Tags:
             result, async-job, status, wait, ai
         """
@@ -212,18 +215,18 @@ class FalaiApp(APIApplication):
         self, request_id: str, application: str = "fal-ai/flux/dev"
     ) -> None:
         """
-        Asynchronously cancels a running or queued Fal AI request.
-
+        Asynchronously cancels a running or queued Fal AI job identified by its `request_id`. This function complements the `submit` method, providing a way to terminate asynchronous tasks before completion. API errors during the cancellation process are wrapped in a `ToolError`.
+        
         Args:
             request_id: The unique identifier of the submitted Fal AI request to cancel
             application: The name or ID of the Fal application (defaults to 'fal-ai/flux/dev')
-
+        
         Returns:
             None. The function doesn't return any value.
-
+        
         Raises:
             ToolError: Raised when the cancellation request fails due to API errors or if the request cannot be cancelled
-
+        
         Tags:
             cancel, async_job, ai, fal, management
         """
@@ -241,17 +244,17 @@ class FalaiApp(APIApplication):
 
     async def upload_file(self, path: str) -> str:
         """
-        Uploads a local file to the Fal CDN and returns its public URL
-
+        Asynchronously uploads a local file from a specified path to the Fal Content Delivery Network (CDN). Upon success, it returns a public URL for the file, making it accessible for use as input in other Fal AI application requests. A `ToolError` is raised on failure.
+        
         Args:
             path: The absolute or relative path to the local file
-
+        
         Returns:
             A string containing the public URL of the uploaded file on the CDN
-
+        
         Raises:
             ToolError: If the file is not found or if the upload operation fails
-
+        
         Tags:
             upload, file, cdn, storage, async, important
         """
@@ -265,7 +268,7 @@ class FalaiApp(APIApplication):
             logger.error(f"Error uploading file {path} to Fal CDN: {e}", exc_info=True)
             raise ToolError(f"Failed to upload file {path}: {e}") from e
 
-    async def generate_image(
+    async def run_image_generation(
         self,
         prompt: str,
         seed: int | None = 6252023,
@@ -277,8 +280,8 @@ class FalaiApp(APIApplication):
         hint: str | None = None,
     ) -> Any:
         """
-        Asynchronously generates images using the 'fal-ai/flux/dev' application with customizable parameters and default settings
-
+        A specialized wrapper for the `run` method that synchronously generates images using the 'fal-ai/flux/dev' model. It simplifies image creation with common parameters like `prompt` and `seed`, waits for the task to complete, and returns the result containing image URLs and metadata.
+        
         Args:
             prompt: The text prompt used to guide the image generation
             seed: Random seed for reproducible image generation (default: 6252023)
@@ -288,13 +291,13 @@ class FalaiApp(APIApplication):
             path: Subpath for the application endpoint (rarely used)
             timeout: Maximum time in seconds to wait for the request to complete
             hint: Hint string for runner selection
-
+        
         Returns:
             A dictionary containing the generated image URLs and related metadata
-
+        
         Raises:
             ToolError: When the image generation request fails or encounters an error
-
+        
         Tags:
             generate, image, ai, async, important, flux, customizable, default
         """
@@ -324,9 +327,9 @@ class FalaiApp(APIApplication):
         return [
             self.run,
             self.submit,
-            self.status,
-            self.result,
+            self.check_status,
+            self.get_result,
             self.cancel,
             self.upload_file,
-            self.generate_image,
+            self.run_image_generation,
         ]