universal-mcp-applications 0.1.16__py3-none-any.whl → 0.1.18__py3-none-any.whl

universal_mcp/applications/falai/app.py

@@ -29,7 +29,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()
@@ -101,7 +101,7 @@ 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
@@ -181,7 +181,7 @@ 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
@@ -215,7 +215,7 @@ 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
@@ -244,7 +244,7 @@ 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
@@ -280,7 +280,7 @@ 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

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,7 +166,7 @@ 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.
@@ -198,7 +198,7 @@ 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.
@@ -232,7 +232,7 @@ 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.
@@ -268,7 +268,7 @@ 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.
@@ -303,7 +303,7 @@ 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.
@@ -342,7 +342,7 @@ 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.
@@ -377,7 +377,7 @@ 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.
@@ -421,7 +421,7 @@ 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.
@@ -476,7 +476,7 @@ 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.

universal_mcp/applications/github/app.py

@@ -25,7 +25,7 @@ class GithubApp(APIApplication):
 
     def star_repository(self, repo_full_name: str) -> str:
         """
-        Stars a GitHub repository for the authenticated user via an API request. It uses the repository's full name ('owner/repo') and returns a string message indicating whether the operation was successful, the repository was not found, or an error occurred.
+        Stars a GitHub repository for the authenticated user. This user-centric action takes the full repository name ('owner/repo') and returns a simple string message confirming the outcome, unlike other functions that list or create repository content like issues or pull requests.
         
         Args:
             repo_full_name: The full name of the repository in 'owner/repo' format (e.g., 'octocat/Hello-World')
@@ -52,7 +52,7 @@ class GithubApp(APIApplication):
 
     def list_recent_commits(self, repo_full_name: str) -> str:
         """
-        Fetches and formats the 12 most recent commits from a GitHub repository. It returns a human-readable string summarizing each commit's hash, author, and message, providing a quick overview of recent code changes, distinct from functions that list branches, issues, or pull requests.
+        Fetches and formats the 12 most recent commits from a repository. It returns a human-readable string summarizing each commit's hash, author, and message, providing a focused overview of recent code changes, unlike functions that list branches, issues, or pull requests.
         
         Args:
             repo_full_name: The full name of the repository in 'owner/repo' format
@@ -85,7 +85,7 @@ class GithubApp(APIApplication):
 
     def list_branches(self, repo_full_name: str) -> str:
         """
-        Retrieves all branches for a specified GitHub repository via the API. It formats the results into a human-readable string listing each branch name, suitable for direct user display. This contrasts with functions like `list_issues`, which return raw API data.
+        Fetches all branches for a specified GitHub repository and formats them into a human-readable string. This method is distinct from others like `search_issues`, as it returns a formatted list for display rather than raw JSON data for programmatic use.
         
         Args:
             repo_full_name: The full name of the repository in 'owner/repo' format (e.g., 'octocat/Hello-World')
@@ -115,7 +115,7 @@ class GithubApp(APIApplication):
 
     def list_pull_requests(self, repo_full_name: str, state: str = "open") -> str:
         """
-        Fetches pull requests for a repository, filtered by state (e.g., 'open'). It returns a formatted string summarizing each PR's details. This differs from `get_pull_request`, which fetches a single PR, and `list_issues`, which returns raw JSON data for a different entity.
+        Fetches pull requests for a repository, filtered by state (e.g., 'open'). It returns a formatted string summarizing each PR's details, distinguishing it from `get_pull_request` (single PR) and `search_issues` (raw issue data).
         
         Args:
             repo_full_name: The full name of the repository in the format 'owner/repo' (e.g., 'tensorflow/tensorflow')
@@ -193,7 +193,7 @@ class GithubApp(APIApplication):
 
     def get_pull_request(self, repo_full_name: str, pull_number: int) -> str:
         """
-        Fetches a specific pull request from a repository by its number. The function returns a formatted string summarizing its title, creator, status, and description, unlike `list_pull_requests`, which fetches a list.
+        Fetches a specific pull request from a repository using its unique number. It returns a human-readable string summarizing the PR's title, creator, status, and description, unlike `list_pull_requests` which retrieves a list of multiple PRs.
         
         Args:
             repo_full_name: The full repository name in 'owner/repo' format (e.g., 'octocat/Hello-World')
@@ -239,7 +239,7 @@ class GithubApp(APIApplication):
         draft: bool = False,
     ) -> dict[str, Any]:
         """
-        Creates a pull request in a repository between specified `head` and `base` branches. It can also convert an existing issue into a pull request by providing an issue number. Returns the complete GitHub API response as a dictionary upon successful creation.
+        Creates a pull request between specified `head` and `base` branches, or converts an issue into a PR. Unlike read functions that return formatted strings, this write operation returns the raw API response as a dictionary, providing comprehensive data on the newly created pull request.
         
         Args:
             repo_full_name: The full name of the repository (e.g. 'owner/repo')
@@ -285,7 +285,7 @@ class GithubApp(APIApplication):
         self, repo_full_name: str, title: str, body: str = "", labels=None
     ) -> str:
         """
-        Creates a new issue in a specified GitHub repository with a title, body, and optional labels. This function sends a POST request to the API and returns a formatted confirmation string containing the new issue's number and URL upon successful creation.
+        Creates a new issue in a GitHub repository using a title, body, and optional labels. It returns a formatted confirmation string with the new issue's number and URL, differing from `update_issue` which modifies existing issues and `search_issues` which returns raw API data.
         
         Args:
             repo_full_name: The full name of the repository in 'owner/repo' format
@@ -328,7 +328,7 @@ class GithubApp(APIApplication):
         self, repo_full_name: str, direction: str = "desc", per_page: int = 30
     ) -> str:
         """
-        Fetches a list of recent events for a GitHub repository and formats them into a human-readable string. It summarizes activities with actors and timestamps, providing a general event feed, unlike other `list_*` functions which retrieve specific resources like commits or issues.
+        Fetches recent events for a GitHub repository and formats them into a human-readable string. It summarizes activities with actors and timestamps, providing a general event feed, unlike other `list_*` functions which retrieve specific resources like commits or issues.
         
         Args:
             repo_full_name: The full name of the repository in 'owner/repo' format
@@ -376,7 +376,7 @@ class GithubApp(APIApplication):
         state_reason: str = None,
     ) -> dict[str, Any]:
         """
-        Modifies an existing GitHub issue in a repository by updating optional parameters like title, body, assignee, or state. It targets the issue by its number and returns the complete API response as a dictionary, contrasting with `create_issue` which creates new issues.
+        Modifies an existing GitHub issue, identified by its number within a repository. It can update optional fields like title, body, or state and returns the raw API response as a dictionary, differentiating it from `create_issue` which makes new issues and returns a formatted string.
         
         Args:
             repo_full_name: The full name of the repository in 'owner/repo' format

universal_mcp/applications/google_calendar/app.py

@@ -54,7 +54,7 @@ class GoogleCalendarApp(APIApplication):
         time_zone: str | None = None,
     ) -> dict[str, Any]:
         """
-        Retrieves calendar events for a specified number of days starting from today. It defaults to fetching only the current day's events, simplifying date-range queries for upcoming events in contrast to the more comprehensive `list_events` function which requires explicit start and end times.
+        Retrieves events for a specified number of days, starting from today. This function simplifies date-range queries by auto-calculating start/end times, unlike the more comprehensive `list_events` function, which offers granular control with explicit time filters, text search, and custom sorting.
         
         Args:
             days: Number of days to retrieve events for (default: 1, which is just today)
@@ -98,7 +98,7 @@ class GoogleCalendarApp(APIApplication):
         time_zone: str | None = None,
     ) -> dict[str, Any]:
         """
-        Retrieves a specific Google Calendar event using its unique ID. Optional parameters can limit the number of attendees returned and specify a time zone for formatting dates. It is distinct from `list_events`, which fetches multiple events based on broader criteria like date ranges or search queries.
+        Retrieves a specific calendar event using its unique ID. Unlike `list_events`, which fetches multiple events based on date ranges or search queries, this function targets a single, known event. It can optionally limit attendees returned and specify a time zone for date formatting in the response.
         
         Args:
             event_id: The unique identifier of the calendar event to retrieve
@@ -137,7 +137,7 @@ class GoogleCalendarApp(APIApplication):
         page_token: str | None = None,
     ) -> dict[str, Any]:
         """
-        Fetches a customizable list of events using filters for date range, text search, sorting, and pagination. This advanced function provides more granular control than `get_today_events`, which is limited to fetching events for a specific number of upcoming days.
+        Fetches a customizable list of events using filters for date range, text search, sorting, and pagination. This advanced function provides more granular control than `get_upcoming_events`, which is limited to fetching events for a specific number of upcoming days.
         
         Args:
             max_results: Maximum number of events to return (default: 10, max: 2500)
@@ -196,7 +196,7 @@ class GoogleCalendarApp(APIApplication):
         calendar_id: str = "primary",
     ) -> dict[str, Any]:
         """
-        Creates a detailed calendar event with structured data, including start/end times, summary, attendees, and recurrence rules. Unlike `quick_add_event`, which uses natural language, this method offers precise control for creating complex or recurring appointments.
+        Creates a calendar event using structured data for start/end times, summary, attendees, and recurrence. This method provides precise control for complex appointments, unlike `create_event_from_text` which parses natural language, making it ideal for detailed or recurring event creation.
         
         Args:
             start: Start time of the event (required). Must include timezone offset or timeZone field.
@@ -254,7 +254,7 @@ class GoogleCalendarApp(APIApplication):
 
     def create_event_from_text(self, text: str, send_updates: str = "none") -> dict[str, Any]:
         """
-        Creates a calendar event by parsing a natural language string for details like title and time. This provides a user-friendly shortcut for event creation, contrasting with the structured `add_an_event` method which requires explicit fields for start, end, and summary.
+        Creates a calendar event by parsing a natural language string (e.g., "Meeting tomorrow at 10am"). This offers a user-friendly shortcut, contrasting with the structured `create_event` function which requires explicit fields like start and end times.
         
         Args:
             text: Natural language text describing the event (e.g., 'Meeting with John at Coffee Shop tomorrow 3pm-4pm')
@@ -287,7 +287,7 @@ class GoogleCalendarApp(APIApplication):
         page_token: str | None = None,
     ) -> dict[str, Any]:
         """
-        Retrieves all individual occurrences (instances) of a specific recurring event, identified by its ID. This function allows filtering by a time range and supports pagination, distinguishing it from `list_events` which fetches multiple, distinct events rather than instances of a single one.
+        Retrieves all individual occurrences of a specific recurring event using its ID. Unlike `list_events`, which fetches multiple distinct events, this function expands a single recurring event into its separate instances, allowing filtering by time range and pagination for detailed scheduling views.
         
         Args:
             event_id: ID of the recurring event
@@ -341,7 +341,7 @@ class GoogleCalendarApp(APIApplication):
         userIp=None,
     ) -> Any:
         """
-        Deletes a specific event from a Google Calendar using its event and calendar IDs. This action is permanent and can optionally send cancellation notifications or updates to attendees based on the provided parameters.
+        Permanently deletes a specific event from a Google Calendar using its event and calendar IDs. It can optionally send cancellation notifications to attendees, distinguishing it from functions that retrieve (`get_event_by_id`) or modify events (`replace_event`), which do not remove entries from the calendar.
         
         Args:
             calendarId (string): calendarId
@@ -400,7 +400,7 @@ class GoogleCalendarApp(APIApplication):
         max_attendees: int | None = None,
     ) -> dict[str, Any]:
         """
-        Replaces an existing calendar event, identified by its ID, with new data. This function performs a full update, overwriting all event properties like start/end times, summary, and attendees. It does not support partial modifications; all required fields for the new event version are necessary.
+        Replaces an existing calendar event, identified by its ID, with new data. This function performs a full update, overwriting all event properties like start/end times and summary. It does not support partial modifications, requiring all necessary fields for the replacement to be provided.
         
         Args:
             event_id: The unique identifier of the calendar event to update (required)
@@ -458,7 +458,7 @@ class GoogleCalendarApp(APIApplication):
 
     def get_primary_calendar_details(self) -> dict[str, Any]:
         """
-        Retrieves metadata for the user's primary calendar, including its default timezone. This information is essential for creating new events with accurate, timezone-aware start and end times, as recommended before using functions like `add_an_event` to prevent scheduling errors across different regions.
+        Retrieves metadata for the user's primary calendar, including its default timezone. This information is essential for creating new events with accurate, timezone-aware start and end times using other functions like `create_event`, preventing potential scheduling errors across different regions.
         
         Returns:
             Dictionary containing the user's timezone information
@@ -491,7 +491,7 @@ class GoogleCalendarApp(APIApplication):
         timeZone=None,
     ) -> dict[str, Any]:
         """
-        Queries the Google Calendar API to determine the free/busy status for one or more calendars within a specified time range. It returns a list of busy time intervals, useful for scheduling new events without conflicts.
+        Queries the free/busy status for one or more calendars within a specified time range. It returns a list of busy time intervals, making it ideal for finding open slots and scheduling new events without conflicts.
         
         
         Args:

universal_mcp/applications/google_docs/app.py

@@ -11,7 +11,7 @@ class GoogleDocsApp(APIApplication):
 
     def create_document(self, title: str) -> dict[str, Any]:
         """
-        Creates a new, blank Google Document with a specified title via a POST request to the Google Docs API. It returns the API response containing the new document's metadata, including its ID, which is necessary for other functions like `add_content` or `get_document` to interact with it.
+        Creates a blank Google Document with a specified title using a POST request to the Google Docs API. This is the primary creation method, returning the document's metadata, including the ID required by functions like `get_document` or `insert_text` to perform subsequent operations on the new file.
         
         Args:
             title: The title for the new Google Document to be created
@@ -34,7 +34,7 @@ class GoogleDocsApp(APIApplication):
 
     def get_document(self, document_id: str) -> dict[str, Any]:
         """
-        Retrieves the complete content and metadata for a specific Google Document by its unique ID. This function queries the Google Docs API and returns the full JSON response, representing the document's latest version. It's the primary read operation, contrasting with `create_document` which creates new ones.
+        Retrieves the complete content and metadata for a specific Google Document using its unique ID. This function performs a GET request to the API, returning the full JSON response. It's the primary read operation, contrasting with `create_document` which creates new documents.
         
         Args:
             document_id: The unique identifier of the document to retrieve
@@ -57,7 +57,7 @@ class GoogleDocsApp(APIApplication):
         self, document_id: str, content: str, index: int = 1
     ) -> dict[str, Any]:
         """
-        Inserts a string of text at a specified index in an existing Google Document using the `batchUpdate` API. This function specifically adds new textual content, distinguishing it from functions that insert tables or apply styling to existing text.
+        Inserts a text string at a specified index within an existing Google Document using the `batchUpdate` API. This function adds new textual content, distinguishing it from functions that insert non-text elements like tables or apply formatting (`apply_text_style`) to existing content.
         
         Args:
             document_id: The unique identifier of the Google Document to be updated
@@ -204,7 +204,7 @@ class GoogleDocsApp(APIApplication):
         tab_id: str | None = None,
     ) -> dict[str, Any]:
         """
-        Applies paragraph formatting, such as named styles ('TITLE', 'HEADING_1'), alignment, and text direction, to a specified range in a Google Document. It selectively updates only the provided style attributes, distinguishing it from `style_text`, which handles character-level formatting like bolding or italics.
+        Applies paragraph-level formatting, such as named styles (e.g., 'HEADING_1'), alignment, or text direction, to a specified text range. This function handles block-level styles, distinguishing it from `apply_text_style`, which formats individual characters with attributes like bold or italic.
         
         Args:
             document_id: The unique identifier of the Google Document to be updated
@@ -286,7 +286,7 @@ class GoogleDocsApp(APIApplication):
         tab_id: str | None = None,
     ) -> dict[str, Any]:
         """
-        Deletes content within a specified range in a Google Document via a `batchUpdate` API call. The function targets a range defined by start and end indexes and can operate within optional segments like headers or footers, returning the API's response after the deletion operation.
+        Deletes content within a specified index range in a Google Document via the batchUpdate API. It removes any content based on location, distinguishing it from functions like `delete_header` or `delete_paragraph_bullets`, which remove specific structures or styles instead.
         
         Args:
             document_id: The unique identifier of the Google Document to be updated
@@ -333,7 +333,7 @@ class GoogleDocsApp(APIApplication):
         tab_id: str = None,
     ) -> dict[str, Any]:
         """
-        Inserts a table with specified row and column dimensions at a given location in a Google Document. It uses the `batchUpdate` API endpoint for precise placement within the document's body, header, or footer, returning the API response.
+        Inserts a table with specified row and column dimensions at a given index in a Google Document. This function uses the `batchUpdate` API for precise placement, allowing the table to be added to the document's body, a header, or a footer, returning the API's response.
         
         Args:
             document_id: The unique identifier of the Google Document to be updated
@@ -390,7 +390,7 @@ class GoogleDocsApp(APIApplication):
         section_break_tab_id: str = None,
     ) -> dict[str, Any]:
         """
-        Creates a footer of a specified type in a Google Document via the batch update API. The footer can optionally be associated with a specific section break, enabling distinct footers for different document sections, distinguishing it from `create_header`.
+        Creates a footer of a specified type in a Google Document via the batch update API. The footer can optionally be associated with a specific section break, enabling distinct footers for different document sections, distinguishing it from the `create_header` and `create_footnote` functions.
         
         Args:
             document_id: The unique identifier of the Google Document to be updated
@@ -442,7 +442,7 @@ class GoogleDocsApp(APIApplication):
         end_of_segment_tab_id: str = None,
     ) -> dict[str, Any]:
         """
-        Creates a footnote segment and inserts a corresponding reference into a Google Document via the API's batch update. The reference can be placed at a specific index or at the end of a document segment. Unlike `create_footer`, this adds a numbered citation within the document body.
+        Creates a footnote via the batch update API, inserting a numbered reference at a specified index or a segment's end. This function adds an in-body citation, distinguishing it from `create_footer` which creates a content block at the bottom of the page.
         
         Args:
             document_id: The unique identifier of the Google Document to be updated
@@ -505,7 +505,7 @@ class GoogleDocsApp(APIApplication):
         tab_id: str = None,
     ) -> dict[str, Any]:
         """
-        Deletes a specific footer from a Google Document using its unique ID (`footer_id`). This function constructs and sends a `deleteFooter` request to the Google Docs API's batch update endpoint, optionally targeting a footer within a specific document tab.
+        Deletes a specific footer from a Google Document using its unique ID via a `batchUpdate` request. This operation, the counterpart to `create_footer`, removes an entire footer section, unlike `delete_content_range` which targets text within a specified index range.
         
         Args:
             document_id: The unique identifier of the Google Document to be updated
@@ -593,7 +593,7 @@ class GoogleDocsApp(APIApplication):
         tab_id: str = None,
     ) -> dict[str, Any]:
         """
-        Removes a specific header from a Google Document using its unique ID. This function constructs and sends a `deleteHeader` request to the Google Docs API's batch update endpoint, acting as the direct counterpart to the `create_header` function.
+        Removes a specific header from a Google Document using its unique ID. This function sends a `deleteHeader` request to the batch update API, acting as the direct counterpart to `create_header` and distinguishing it from `delete_footer` which removes footers.
         
         Args:
             document_id: The unique identifier of the Google Document to be updated
@@ -634,7 +634,7 @@ class GoogleDocsApp(APIApplication):
         tab_id: str = None,
     ) -> dict[str, Any]:
         """
-        Applies a specified bulleted or numbered list format to paragraphs within a given range in a Google Document. The list style is determined by a predefined preset, covering various bullet glyphs and numbering schemes like 'BULLET_DISC_CIRCLE_SQUARE' or 'NUMBERED_DECIMAL_ALPHA_ROMAN'.
+        Applies a predefined bulleted or numbered list format to paragraphs within a specified range using a `bullet_preset`. This function adds list formatting, distinguishing it from its counterpart, `delete_paragraph_bullets`, and other styling functions like `update_paragraph_style`, which handles alignment and headings.
         
         Args:
             document_id: The unique identifier of the Google Document to be updated
@@ -704,7 +704,7 @@ class GoogleDocsApp(APIApplication):
         tab_id: str = None,
     ) -> dict[str, Any]:
         """
-        Removes bullet points or numbering from paragraphs within a specified range in a Google Document. This function uses the API's batch update feature to revert list formatting, acting as the direct counterpart to `create_paragraph_bullets` for removing list styles, rather than deleting text content.
+        Removes bullet points or numbering from paragraphs within a specified range in a Google Document. This function reverts list formatting via the batch update API, acting as the direct counterpart to `apply_list_style` and preserving the underlying text content, unlike `delete_content_range`.
         
         Args:
             document_id: The unique identifier of the Google Document to be updated