universal-mcp-applications 0.1.17__tar.gz → 0.1.18__tar.gz

universal_mcp_applications-0.1.18/.gitignore

@@ -0,0 +1,60 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Environment variables
+.env
+.env.local
+
+
+dump/
+
+
+# SQLite database
+*.db
+*.sqlite
+*.sqlite3
+*.db-shm
+*.db-wal
+
+
+# Pyright
+.pyright
+
+# Ruff
+.ruff_cache
+
+# Pytest
+.pytest_cache
+
+
+# Local config
+local_config.json
+
+
+# Test Artifacts
+test_artifacts/
+src/universal_mcp/applications/complex/
+src/universal_mcp/applications/test/
+src/universal_mcp/applications/test_with_docs/
+src/universal_mcp/applications/test_without_docs/
+
+# Temporary files
+tmp/
+
+
+# Docs
+site/
+.cache/
+
+# langgraph temporary files
+.langgraph_api/
+langgraph.json
+agentr-1-6c4ebd5cc914.json

{universal_mcp_applications-0.1.17 → universal_mcp_applications-0.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-applications
-Version: 0.1.17
+Version: 0.1.18
 Summary: A Universal MCP Application: universal_mcp_applications
 Project-URL: Homepage, https://github.com/universal-mcp/applications
 Project-URL: Repository, https://github.com/universal-mcp/applications

{universal_mcp_applications-0.1.17 → universal_mcp_applications-0.1.18}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp-applications"
-version = "0.1.17"
+version = "0.1.18"
 description = "A Universal MCP Application: universal_mcp_applications"
 readme = "README.md"
 requires-python = ">=3.11"

{universal_mcp_applications-0.1.17 → universal_mcp_applications-0.1.18}/src/scripts/docgen.py

@@ -30,7 +30,7 @@ class DescriptionOutput(BaseModel):
     """Structure for the generated description output."""
 
     description: str = Field(description="A clear, detailed description of what the function does")
-    suggested_name: Optional[str] = Field(None, description="A better name for the function, if applicable")
+    # suggested_name: Optional[str] = Field(None, description="A better name for the function, if applicable")
 
 
 class FunctionExtractor(ast.NodeVisitor):
@@ -244,7 +244,7 @@ def generate_description(
                 parsed_data = extract_json_from_text(response_text)
                 return DescriptionOutput(
                     description=parsed_data.get("description", "No description available."),
-                    suggested_name=parsed_data.get("suggested_name"),
+                    # suggested_name=parsed_data.get("suggested_name"),
                 )
             except ValueError as e:
                 print(f"  - JSON extraction failed: {e}")
@@ -442,7 +442,7 @@ def process_file(file_path: str, model: str = "perplexity/sonar") -> int:
         # 1. Generate new description and check for suggested name
         output = generate_description(function_code, original_content, model)
         new_description = output.description.strip()
-        suggested_name = output.suggested_name
+        # suggested_name = output.suggested_name
 
         if not new_description or "Error generating description" in new_description:
             print(f"  - Failed to generate description for '{function_name}', skipping.")
@@ -456,10 +456,10 @@ def process_file(file_path: str, model: str = "perplexity/sonar") -> int:
         # 3. Handle function renaming if suggested
         code_to_update = function_code
         is_renamed = False
-        if suggested_name and suggested_name != function_name:
-            print(f"  - Renaming function '{function_name}' to '{suggested_name}'")
-            code_to_update = rename_function_in_code(code_to_update, function_name, suggested_name)
-            is_renamed = True
+        # if suggested_name and suggested_name != function_name:
+        #     print(f"  - Renaming function '{function_name}' to '{suggested_name}'")
+        #     code_to_update = rename_function_in_code(code_to_update, function_name, suggested_name)
+        #     is_renamed = True
 
         # 4. Insert the new docstring back into the (potentially renamed) function code
         updated_function_block = insert_docstring_into_function(code_to_update, reconstructed_docstring)
@@ -468,11 +468,11 @@ def process_file(file_path: str, model: str = "perplexity/sonar") -> int:
         if updated_function_block != function_code:
             updated_content = updated_content.replace(function_code, updated_function_block)
             count += 1
-            print(f"  - Updated function block for '{suggested_name or function_name}'.")
+            print(f"  - Updated function block for '{function_name}'.")
             
             # 6. If the function was renamed, also update the list_tools method
-            if is_renamed:
-                updated_content = update_list_tools_method(updated_content, function_name, suggested_name)
+            # if is_renamed:
+            #     updated_content = update_list_tools_method(updated_content, function_name, suggested_name)
 
     if updated_content != original_content:
         with open(file_path, "w", encoding="utf-8") as f:

{universal_mcp_applications-0.1.17 → universal_mcp_applications-0.1.18}/src/scripts/prompts.py

@@ -6,7 +6,6 @@ You will be given the full context of a Python script, followed by a request to
 
 Your tasks are:
 1.  **Write a High-Quality Description:** The description should be comprehensive, clear, and accurately reflect the function's purpose.
-2.  **Suggest a Better Name (If Necessary):** Analyze the function's original name. If you believe a different name would be more descriptive or intuitive based on what the function does, suggest a new one. If the current name is good, you can omit this suggestion.
 3.  **Differentiate Similar Functions:** Use the full script context to clarify the unique role of this function, especially if other functions have similar names or functionality.
 
 The full script content is:
@@ -15,14 +14,13 @@ The full script content is:
 --- SCRIPT END ---
 """
 
-USER_PROMPT_TEMPLATE = """Based on the full script provided, analyze the following Python function. Generate a high-quality description and, if you think it's necessary, suggest a better name for it.
+USER_PROMPT_TEMPLATE = """Based on the full script provided, analyze the following Python function. Generate a high-quality description.
 
 Function to analyze:
 ```python
 {function_code}
-Respond ONLY in the following JSON format. If you do not want to suggest a new name, you can omit the "suggested_name" key.
+Respond ONLY in the following JSON format.
 {{
 "description": "A clear and detailed description of what the function does, taking into account the full script context.",
-"suggested_name": "A more descriptive and clear name for the function (optional)"
 }}
 """

{universal_mcp_applications-0.1.17 → universal_mcp_applications-0.1.18}/src/scripts/run_docgen.py

@@ -3,41 +3,15 @@ import os
 import subprocess
 
 APPS = [
-    "aws_s3",
-    "calendly",
-    "canva",
-    "domain_checker",
-    "e2b",
-    "elevenlabs",
-    "exa",
-    "falai",
-    "file_system",
-    "firecrawl",
-    "fireflies",
-    "fpl",
+    "google_mail",
     "google_calendar",
     "google_docs",
     "google_drive",
     "google_searchconsole",
     "google_sheet",
-    "http_tools",
     "linkedin",
     "ms_teams",
-    "openai",
     "outlook",
-    "replicate",
-    "resend",
-    "scraper",
-    "serpapi",
-    "sharepoint",
-    "slack",
-    "tavily",
-    "twitter",
-    "unipile",
-    "whatsapp",
-    "whatsapp_business",
-    "youtube",
-    "zenquotes",
 ]
 
 def main():

{universal_mcp_applications-0.1.17 → universal_mcp_applications-0.1.18}/src/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-0.1.17 → universal_mcp_applications-0.1.18}/src/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-0.1.17 → universal_mcp_applications-0.1.18}/src/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-0.1.17 → universal_mcp_applications-0.1.18}/src/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: