universal-mcp-applications 0.1.17__py3-none-any.whl → 0.1.33__py3-none-any.whl

universal_mcp/applications/falai/app.py

@@ -3,7 +3,6 @@ from typing import Any, Literal
 
 from fal_client import AsyncClient, AsyncRequestHandle, Status
 from loguru import logger
-
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.exceptions import NotAuthorizedError, ToolError
 from universal_mcp.integrations import Integration
@@ -29,7 +28,7 @@ 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.
+        A cached property that lazily initializes an `AsyncClient` instance. It retrieves the API key from the configured integration, providing a single, centralized authentication point for all methods that interact with the Fal AI API. Raises `NotAuthorizedError` if credentials are not found.
         """
         if self._fal_client is None:
             credentials = self.integration.get_credentials()
@@ -59,20 +58,20 @@ class FalaiApp(APIApplication):
     ) -> Any:
         """
         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
         """
@@ -101,8 +100,8 @@ class FalaiApp(APIApplication):
         priority: Priority | None = None,
     ) -> str:
         """
-        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.
-        
+        Submits a job to the Fal AI queue for asynchronous processing, immediately returning a request ID. This contrasts with the `run` method, which waits for completion. The returned ID is used by `check_status`, `get_result`, and `cancel` to manage the job's lifecycle.
+
         Args:
             arguments: A dictionary of arguments for the application
             application: The name or ID of the Fal application, defaulting to 'fal-ai/flux/dev'
@@ -110,13 +109,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
         """
@@ -147,18 +146,18 @@ class FalaiApp(APIApplication):
     ) -> Status:
         """
         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
         """
@@ -181,18 +180,18 @@ class FalaiApp(APIApplication):
         self, request_id: str, application: str = "fal-ai/flux/dev"
     ) -> Any:
         """
-        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.
-        
+        Retrieves the final result of an asynchronous job, identified by its `request_id`. This function waits for the job, initiated via `submit`, to complete. Unlike the non-blocking `check_status`, this method blocks execution to fetch and return the job's actual output upon completion.
+
         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
         """
@@ -215,18 +214,18 @@ class FalaiApp(APIApplication):
         self, request_id: str, application: str = "fal-ai/flux/dev"
     ) -> None:
         """
-        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`.
-        
+        Asynchronously cancels a running or queued Fal AI job using its `request_id`. This function complements the `submit` method, providing a way to terminate asynchronous tasks before completion. It raises a `ToolError` if the cancellation request fails.
+
         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
         """
@@ -244,17 +243,17 @@ class FalaiApp(APIApplication):
 
     async def upload_file(self, path: str) -> str:
         """
-        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.
-        
+        Asynchronously uploads a local file to the Fal Content Delivery Network (CDN), returning a public URL. This URL makes the file accessible for use as input in other Fal AI job execution methods like `run` or `submit`. A `ToolError` is raised if the upload fails.
+
         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
         """
@@ -280,8 +279,8 @@ class FalaiApp(APIApplication):
         hint: str | None = None,
     ) -> Any:
         """
-        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.
-        
+        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 directly 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)
@@ -291,13 +290,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
         """

universal_mcp/applications/figma/README.md

@@ -1,10 +1,10 @@
-# Figma MCP Server
+# FigmaApp MCP Server
 
-An MCP Server for the Figma API.
+An MCP Server for the FigmaApp API.
 
 ## 🛠️ Tool List
 
-This is automatically generated from OpenAPI schema for the Figma API.
+This is automatically generated from OpenAPI schema for the FigmaApp API.
 
 
 | Tool | Description |

universal_mcp/applications/file_system/README.md

@@ -0,0 +1,13 @@
+# FileSystemApp MCP Server
+
+An MCP Server for the FileSystemApp API.
+
+## 🛠️ Tool List
+
+This is automatically generated from OpenAPI schema for the FileSystemApp API.
+
+
+| Tool | Description |
+|------|-------------|
+| `read_file` | Asynchronously reads the entire content of a specified file in binary mode. This static method takes a file path and returns its data as a bytes object, serving as a fundamental file retrieval operation within the FileSystem application. |
+| `write_file` | Writes binary data to a specified file path. If no path is provided, it creates a unique temporary file in `/tmp`. The function returns a dictionary confirming success and providing metadata about the new file, including its path and size. |

universal_mcp/applications/file_system/app.py

@@ -17,18 +17,18 @@ class FileSystemApp(BaseApplication):
     async def read_file(file_path: str):
         """
         Asynchronously reads the entire content of a specified file in binary mode. This static method takes a file path and returns its data as a bytes object, serving as a fundamental file retrieval operation within the FileSystem application.
-        
+
         Args:
             file_path (str): The path to the file to read.
-        
+
         Returns:
             bytes: The file content as bytes.
-        
+
         Raises:
             FileNotFoundError: If the file doesn't exist.
             IOError: If there's an error reading the file.
-            
-        Tags: 
+
+        Tags:
             important
         """
         with open(file_path, "rb") as f:
@@ -38,12 +38,12 @@ class FileSystemApp(BaseApplication):
     async def write_file(file_data: bytes, file_path: str = None):
         """
         Writes binary data to a specified file path. If no path is provided, it creates a unique temporary file in `/tmp`. The function returns a dictionary confirming success and providing metadata about the new file, including its path and size.
-        
+
         Args:
             file_data (bytes): The data to write to the file.
             file_path (str, optional): The path where to write the file.
                 If None, generates a random path in /tmp. Defaults to None.
-        
+
         Returns:
             dict: A dictionary containing the operation result with keys:
                 - status (str): "success" if the operation completed successfully
@@ -51,11 +51,11 @@ class FileSystemApp(BaseApplication):
                     - url (str): The file path where the data was written
                     - filename (str): The filename (same as url in this implementation)
                     - size (int): The size of the written data in bytes
-        
+
         Raises:
             IOError: If there's an error writing the file.
             PermissionError: If there are insufficient permissions to write to the path.
-            
+
         Tags:
             important
         """

universal_mcp/applications/firecrawl/README.md

@@ -9,12 +9,12 @@ This is automatically generated from OpenAPI schema for the FirecrawlApp API.
 
 | Tool | Description |
 |------|-------------|
-| `scrape_url` | Scrapes a single URL using Firecrawl and returns the extracted data. |
-| `search` | Performs a web search using Firecrawl's search capability. |
-| `start_crawl` | Starts a async crawl job for a given URL using Firecrawl. Returns the job ID immediately. |
-| `check_crawl_status` | Checks the status of a previously initiated async Firecrawl crawl job. |
-| `cancel_crawl` | Cancels a currently running Firecrawl crawl job. |
-| `start_batch_scrape` | Starts a batch scrape job for multiple URLs using Firecrawl. (Note: May map to multiple individual scrapes or a specific batch API endpoint if available) |
-| `check_batch_scrape_status` | Checks the status of a previously initiated Firecrawl batch scrape job. |
-| `quick_web_extract` | Performs a quick, synchronous extraction of data from one or more URLs using Firecrawl and returns the results directly. |
-| `check_extract_status` | Checks the status of a previously initiated Firecrawl extraction job. |
+| `scrape_url` | Synchronously scrapes a single URL, immediately returning its content. This provides a direct method for single-page scraping, contrasting with asynchronous, job-based functions like `start_crawl` (for entire sites) and `start_batch_scrape` (for multiple URLs). |
+| `search` | Executes a synchronous web search using the Firecrawl service for a given query. Unlike scrape_url which fetches a single page, this function discovers web content. It returns a dictionary of results on success or an error string on failure, raising exceptions for authorization or SDK issues. |
+| `start_crawl` | Starts an asynchronous Firecrawl job to crawl a website from a given URL, returning a job ID. Unlike the synchronous `scrape_url` for single pages, this function initiates a comprehensive, link-following crawl. Progress can be monitored using the `check_crawl_status` function with the returned ID. |
+| `check_crawl_status` | Retrieves the status of an asynchronous Firecrawl job using its unique ID. As the counterpart to `start_crawl`, this function exclusively monitors website crawl progress, distinct from status checkers for batch scraping or data extraction jobs. Returns job details on success or an error message on failure. |
+| `cancel_crawl` | Cancels a running asynchronous Firecrawl crawl job using its unique ID. As a lifecycle management tool for jobs initiated by `start_crawl`, it returns a confirmation status upon success or an error message on failure, distinguishing it from controls for other job types. |
+| `start_batch_scrape` | Initiates an asynchronous Firecrawl job to scrape a list of URLs. It returns a job ID for tracking with `check_batch_scrape_status`. Unlike the synchronous `scrape_url` which processes a single URL, this function handles bulk scraping and doesn't wait for completion. |
+| `check_batch_scrape_status` | Checks the status of an asynchronous batch scrape job using its job ID. As the counterpart to `start_batch_scrape`, it specifically monitors multi-URL scraping tasks, distinct from checkers for site-wide crawls (`check_crawl_status`) or AI-driven extractions (`check_extract_status`). Returns detailed progress or an error message. |
+| `quick_web_extract` | Performs synchronous, AI-driven data extraction from URLs using an optional prompt or schema. Unlike asynchronous jobs like `start_crawl`, it returns structured data directly. This function raises an exception on failure, contrasting with other methods in the class that return an error string upon failure. |
+| `check_extract_status` | Checks the status of an asynchronous, AI-powered Firecrawl data extraction job using its ID. Unlike `check_crawl_status` or `check_batch_scrape_status`, this function specifically monitors structured data extraction tasks, returning the job's progress or an error message on failure. |

universal_mcp/applications/firecrawl/app.py

@@ -38,7 +38,7 @@ class FirecrawlApp(APIApplication):
     @property
     def 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 are properly authenticated.
+        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.
         """
         if self._firecrawl_api_key is None:
             if not self.integration:
@@ -166,19 +166,19 @@ class FirecrawlApp(APIApplication):
 
     def scrape_url(self, url: str) -> Any:
         """
-        Synchronously scrapes a single web page's content using the Firecrawl service. This function executes immediately and returns the extracted data, unlike the asynchronous `start_batch_scrape` or `start_crawl` jobs which require status checks. Returns an error message on failure.
-        
+        Synchronously scrapes a single URL, immediately returning its content. This provides a direct method for single-page scraping, contrasting with asynchronous, job-based functions like `start_crawl` (for entire sites) and `start_batch_scrape` (for multiple URLs).
+
         Args:
             url: The URL of the web page to scrape.
-        
+
         Returns:
             A dictionary containing the scraped data on success,
             or a string containing an error message on failure.
-        
+
         Raises:
             NotAuthorizedError: If API key is missing or invalid.
             ToolError: If the Firecrawl SDK is not installed.
-        
+
         Tags:
             scrape, important
         """
@@ -198,19 +198,19 @@ class FirecrawlApp(APIApplication):
 
     def search(self, query: str) -> dict[str, Any] | str:
         """
-        Executes a web search using the Firecrawl service for a specified query. It returns a dictionary of results on success or an error string on failure, raising specific exceptions for authorization or SDK installation issues. This provides a direct, synchronous method for information retrieval.
-        
+        Executes a synchronous web search using the Firecrawl service for a given query. Unlike scrape_url which fetches a single page, this function discovers web content. It returns a dictionary of results on success or an error string on failure, raising exceptions for authorization or SDK issues.
+
         Args:
             query: The search query string.
-        
+
         Returns:
             A dictionary containing the search results on success,
             or a string containing an error message on failure.
-        
+
         Raises:
             NotAuthorizedError: If API key is missing or invalid.
             ToolError: If the Firecrawl SDK is not installed.
-        
+
         Tags:
             search, important
         """
@@ -232,19 +232,19 @@ class FirecrawlApp(APIApplication):
         url: str,
     ) -> dict[str, Any] | str:
         """
-        Initiates an asynchronous Firecrawl job to crawl a website starting from a given URL. It returns immediately with a job ID, which can be used with `check_crawl_status` to monitor progress. This differs from `scrape_url`, which performs a synchronous scrape of a single page.
-        
+        Starts an asynchronous Firecrawl job to crawl a website from a given URL, returning a job ID. Unlike the synchronous `scrape_url` for single pages, this function initiates a comprehensive, link-following crawl. Progress can be monitored using the `check_crawl_status` function with the returned ID.
+
         Args:
             url: The starting URL for the crawl.
-        
+
         Returns:
             A dictionary containing the job initiation response on success,
             or a string containing an error message on failure.
-        
+
         Raises:
             NotAuthorizedError: If API key is missing or invalid.
             ToolError: If the Firecrawl SDK is not installed.
-        
+
         Tags:
             crawl, async_job, start
         """
@@ -268,19 +268,19 @@ class FirecrawlApp(APIApplication):
 
     def check_crawl_status(self, job_id: str) -> dict[str, Any] | str:
         """
-        Retrieves the status of an asynchronous Firecrawl crawl job using its unique ID. Returns a dictionary with the job's details on success or an error message on failure. This function specifically handles jobs initiated by `start_crawl`, distinct from checkers for batch scrapes or extractions.
-        
+        Retrieves the status of an asynchronous Firecrawl job using its unique ID. As the counterpart to `start_crawl`, this function exclusively monitors website crawl progress, distinct from status checkers for batch scraping or data extraction jobs. Returns job details on success or an error message on failure.
+
         Args:
             job_id: The ID of the crawl job to check.
-        
+
         Returns:
             A dictionary containing the job status details on success,
             or a string containing an error message on failure.
-        
+
         Raises:
             NotAuthorizedError: If API key is missing or invalid.
             ToolError: If the Firecrawl SDK is not installed.
-        
+
         Tags:
             crawl, async_job, status
         """
@@ -303,20 +303,20 @@ class FirecrawlApp(APIApplication):
 
     def cancel_crawl(self, job_id: str) -> dict[str, Any] | str:
         """
-        Cancels a running asynchronous Firecrawl crawl job identified by its unique ID. As part of the crawl job lifecycle, this function terminates a process initiated by `start_crawl`, returning a confirmation status upon success or an error message if the cancellation fails or is not supported.
-        
+        Cancels a running asynchronous Firecrawl crawl job using its unique ID. As a lifecycle management tool for jobs initiated by `start_crawl`, it returns a confirmation status upon success or an error message on failure, distinguishing it from controls for other job types.
+
         Args:
             job_id: The ID of the crawl job to cancel.
-        
+
         Returns:
             A dictionary confirming the cancellation status on success,
             or a string containing an error message on failure.
             (Note: This functionality might depend on Firecrawl API capabilities)
-        
+
         Raises:
             NotAuthorizedError: If API key is missing or invalid.
             ToolError: If the Firecrawl SDK is not installed or operation not supported.
-        
+
         Tags:
             crawl, async_job, management, cancel
         """
@@ -342,19 +342,19 @@ class FirecrawlApp(APIApplication):
         urls: list[str],
     ) -> dict[str, Any] | str:
         """
-        Initiates an asynchronous batch job to scrape a list of URLs using Firecrawl. It returns a response containing a job ID, which can be tracked with `check_batch_scrape_status`. This differs from the synchronous `scrape_url` which handles a single URL and returns data directly.
-        
+        Initiates an asynchronous Firecrawl job to scrape a list of URLs. It returns a job ID for tracking with `check_batch_scrape_status`. Unlike the synchronous `scrape_url` which processes a single URL, this function handles bulk scraping and doesn't wait for completion.
+
         Args:
             urls: A list of URLs to scrape.
-        
+
         Returns:
             A dictionary containing the job initiation response (e.g., a batch job ID or list of results/job IDs) on success,
             or a string containing an error message on failure.
-        
+
         Raises:
             NotAuthorizedError: If API key is missing or invalid.
             ToolError: If the Firecrawl SDK is not installed.
-        
+
         Tags:
             scrape, batch, async_job, start
         """
@@ -377,19 +377,19 @@ class FirecrawlApp(APIApplication):
 
     def check_batch_scrape_status(self, job_id: str) -> dict[str, Any] | str:
         """
-        Checks the status of a previously initiated asynchronous Firecrawl batch scrape job using its job ID. It returns detailed progress information or an error message. This function is the counterpart to `start_batch_scrape` for monitoring multi-URL scraping tasks.
-        
+        Checks the status of an asynchronous batch scrape job using its job ID. As the counterpart to `start_batch_scrape`, it specifically monitors multi-URL scraping tasks, distinct from checkers for site-wide crawls (`check_crawl_status`) or AI-driven extractions (`check_extract_status`). Returns detailed progress or an error message.
+
         Args:
             job_id: The ID of the batch scrape job to check.
-        
+
         Returns:
             A dictionary containing the job status details on success,
             or a string containing an error message on failure.
-        
+
         Raises:
             NotAuthorizedError: If API key is missing or invalid.
             ToolError: If the Firecrawl SDK is not installed or operation not supported.
-        
+
         Tags:
             scrape, batch, async_job, status
         """
@@ -421,22 +421,22 @@ class FirecrawlApp(APIApplication):
         allow_external_links: bool | None = False,
     ) -> dict[str, Any]:
         """
-        Performs synchronous, AI-driven data extraction from URLs using an optional prompt or schema. Unlike asynchronous job functions (e.g., `start_crawl`), it returns the structured data directly. This function raises `NotAuthorizedError` or `ToolError` on failure, contrasting with others that return an error string.
-        
+        Performs synchronous, AI-driven data extraction from URLs using an optional prompt or schema. Unlike asynchronous jobs like `start_crawl`, it returns structured data directly. This function raises an exception on failure, contrasting with other methods in the class that return an error string upon failure.
+
         Args:
             urls: A list of URLs to extract data from.
             prompt: Optional custom extraction prompt describing what data to extract.
             schema: Optional JSON schema or Pydantic model for the desired output structure.
             system_prompt: Optional system context for the extraction.
             allow_external_links: Optional boolean to allow following external links.
-        
+
         Returns:
             A dictionary containing the extracted data on success.
-        
+
         Raises:
             NotAuthorizedError: If API key is missing or invalid.
             ToolError: If the Firecrawl SDK is not installed or extraction fails.
-        
+
         Tags:
             extract, ai, sync, quick, important
         """
@@ -476,19 +476,19 @@ class FirecrawlApp(APIApplication):
 
     def check_extract_status(self, job_id: str) -> dict[str, Any] | str:
         """
-        Checks the status of a specific asynchronous, AI-powered data extraction job on Firecrawl using its job ID. This is distinct from `check_crawl_status` for web crawling and `check_batch_scrape_status` for bulk scraping, as it specifically monitors AI-driven extractions.
-        
+        Checks the status of an asynchronous, AI-powered Firecrawl data extraction job using its ID. Unlike `check_crawl_status` or `check_batch_scrape_status`, this function specifically monitors structured data extraction tasks, returning the job's progress or an error message on failure.
+
         Args:
             job_id: The ID of the extraction job to check.
-        
+
         Returns:
             A dictionary containing the job status details on success,
             or a string containing an error message on failure.
-        
+
         Raises:
             NotAuthorizedError: If API key is missing or invalid.
             ToolError: If the Firecrawl SDK is not installed or operation not supported.
-        
+
         Tags:
             extract, ai, async_job, status
         """

universal_mcp/applications/fireflies/README.md

@@ -9,17 +9,17 @@ This is automatically generated from OpenAPI schema for the FirefliesApp API.
 
 | Tool | Description |
 |------|-------------|
-| `get_team_analytics` | Fetches team analytics data within a specified time range. |
-| `get_ai_apps_outputs` | Fetches AI Apps outputs for a given transcript. |
-| `get_user_details` | Fetches details for a specific user. |
-| `list_users` | Fetches a list of users in the workspace. |
-| `get_transcript_details` | Fetches details for a specific transcript. |
-| `list_transcripts` | Fetches a list of transcripts, optionally filtered by user ID. |
-| `get_bite_details` | Fetches details for a specific bite (soundbite/clip). |
-| `list_bites` | Fetches a list of bites, optionally filtered to the current user's bites. |
-| `add_to_live_meeting` | Adds Fireflies.ai to a live meeting. |
-| `create_bite` | Creates a bite (soundbite/clip) from a transcript. |
-| `delete_transcript` | Deletes a transcript. |
-| `set_user_role` | Sets the role for a user. |
-| `upload_audio` | Uploads an audio file for transcription. |
-| `update_meeting_title` | Updates the title of a meeting (transcript). |
+| `get_team_conversation_analytics` | Queries the Fireflies.ai API for team conversation analytics, specifically the average number of filler words. The data retrieval can optionally be filtered by a start and end time. Returns a dictionary containing the fetched analytics. |
+| `get_transcript_ai_outputs` | Retrieves all AI-generated application outputs, such as summaries or analyses, associated with a specific transcript ID. It fetches the detailed prompt and response data for each AI app that has processed the transcript, providing a complete record of AI-generated content. |
+| `get_user_details` | Fetches details, such as name and integrations, for a single user identified by their unique ID. This function queries for a specific user, differentiating it from `list_users` which retrieves a list of all users in the workspace. |
+| `list_users` | Retrieves a list of all users in the workspace, returning each user's name and configured integrations. It provides a complete team roster, differing from `get_user_details`, which fetches information for a single user by their ID. |
+| `get_transcript_details` | Queries the Fireflies API for a single transcript's details, such as title and ID, using its unique identifier. It fetches one specific entry, distinguishing it from `list_transcripts`, which retrieves a collection, and from `get_ai_apps_outputs` which gets AI data from a transcript. |
+| `list_transcripts` | Fetches a list of meeting transcripts, returning the title and ID for each. The list can be filtered to return only transcripts for a specific user. This function complements `get_transcript_details`, which retrieves a single transcript by its unique ID. |
+| `get_bite_details` | Retrieves detailed information for a specific bite (soundbite/clip) using its unique ID. It fetches data including the user ID, name, processing status, and summary. This provides a focused view of a single bite, distinguishing it from `list_bites` which fetches a collection of bites. |
+| `list_bites` | Retrieves a list of soundbites (clips) from the Fireflies API. An optional 'mine' parameter filters for soundbites belonging only to the authenticated user. Differentiates from 'get_bite_details' by fetching multiple items rather than a single one by ID. |
+| `add_to_live_meeting` | Executes a GraphQL mutation to make the Fireflies.ai notetaker join a live meeting specified by its URL. This action initiates the bot's recording and transcription process for the ongoing session and returns a success confirmation. |
+| `create_soundbite_from_transcript` | Creates a soundbite/clip from a specified segment of a transcript using its ID, start, and end times. This function executes a GraphQL mutation, returning details of the newly created bite, such as its ID and processing status. |
+| `delete_transcript` | Permanently deletes a specific transcript from Fireflies.ai using its ID. This destructive operation executes a GraphQL mutation and returns a dictionary containing the details of the transcript (e.g., title, date) as it existed just before being removed, confirming the action. |
+| `set_user_role` | Assigns a new role (e.g., 'admin', 'member') to a user specified by their ID. This function executes a GraphQL mutation to modify user data and returns a dictionary with the user's updated name and admin status to confirm the change. |
+| `transcribe_audio_from_url` | Submits an audio file from a URL to the Fireflies.ai API for transcription. It can optionally associate a title and a list of attendees with the audio, returning the upload status and details upon completion. |
+| `update_transcript_title` | Updates the title of a specific transcript, identified by its ID, to a new value. This function executes a GraphQL mutation and returns a dictionary containing the newly assigned title upon successful completion of the request. |