workspace-mcp 0.2.0__py3-none-any.whl

core/utils.py

@@ -0,0 +1,162 @@
+import io
+import logging
+import os
+import tempfile
+import zipfile, xml.etree.ElementTree as ET
+
+from typing import List, Optional
+
+logger = logging.getLogger(__name__)
+
+def check_credentials_directory_permissions(credentials_dir: str = ".credentials") -> None:
+    """
+    Check if the service has appropriate permissions to create and write to the .credentials directory.
+
+    Args:
+        credentials_dir: Path to the credentials directory (default: ".credentials")
+
+    Raises:
+        PermissionError: If the service lacks necessary permissions
+        OSError: If there are other file system issues
+    """
+    try:
+        # Check if directory exists
+        if os.path.exists(credentials_dir):
+            # Directory exists, check if we can write to it
+            test_file = os.path.join(credentials_dir, ".permission_test")
+            try:
+                with open(test_file, 'w') as f:
+                    f.write("test")
+                os.remove(test_file)
+                logger.info(f"Credentials directory permissions check passed: {os.path.abspath(credentials_dir)}")
+            except (PermissionError, OSError) as e:
+                raise PermissionError(f"Cannot write to existing credentials directory '{os.path.abspath(credentials_dir)}': {e}")
+        else:
+            # Directory doesn't exist, check if we can create it
+            parent_dir = os.path.dirname(os.path.abspath(credentials_dir)) or "."
+            if not os.access(parent_dir, os.W_OK):
+                raise PermissionError(f"Cannot create credentials directory '{os.path.abspath(credentials_dir)}': insufficient permissions in parent directory '{parent_dir}'")
+
+            # Test creating the directory
+            try:
+                os.makedirs(credentials_dir, exist_ok=True)
+                # Test writing to the new directory
+                test_file = os.path.join(credentials_dir, ".permission_test")
+                with open(test_file, 'w') as f:
+                    f.write("test")
+                os.remove(test_file)
+                logger.info(f"Created credentials directory with proper permissions: {os.path.abspath(credentials_dir)}")
+            except (PermissionError, OSError) as e:
+                # Clean up if we created the directory but can't write to it
+                try:
+                    if os.path.exists(credentials_dir):
+                        os.rmdir(credentials_dir)
+                except:
+                    pass
+                raise PermissionError(f"Cannot create or write to credentials directory '{os.path.abspath(credentials_dir)}': {e}")
+
+    except PermissionError:
+        raise
+    except Exception as e:
+        raise OSError(f"Unexpected error checking credentials directory permissions: {e}")
+
+def extract_office_xml_text(file_bytes: bytes, mime_type: str) -> Optional[str]:
+    """
+    Very light-weight XML scraper for Word, Excel, PowerPoint files.
+    Returns plain-text if something readable is found, else None.
+    No external deps – just std-lib zipfile + ElementTree.
+    """
+    shared_strings: List[str] = []
+    ns_excel_main = 'http://schemas.openxmlformats.org/spreadsheetml/2006/main'
+
+    try:
+        with zipfile.ZipFile(io.BytesIO(file_bytes)) as zf:
+            targets: List[str] = []
+            # Map MIME → iterable of XML files to inspect
+            if mime_type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+                targets = ["word/document.xml"]
+            elif mime_type == "application/vnd.openxmlformats-officedocument.presentationml.presentation":
+                targets = [n for n in zf.namelist() if n.startswith("ppt/slides/slide")]
+            elif mime_type == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
+                targets = [n for n in zf.namelist() if n.startswith("xl/worksheets/sheet") and "drawing" not in n]
+                # Attempt to parse sharedStrings.xml for Excel files
+                try:
+                    shared_strings_xml = zf.read("xl/sharedStrings.xml")
+                    shared_strings_root = ET.fromstring(shared_strings_xml)
+                    for si_element in shared_strings_root.findall(f"{{{ns_excel_main}}}si"):
+                        text_parts = []
+                        # Find all <t> elements, simple or within <r> runs, and concatenate their text
+                        for t_element in si_element.findall(f".//{{{ns_excel_main}}}t"):
+                            if t_element.text:
+                                text_parts.append(t_element.text)
+                        shared_strings.append("".join(text_parts))
+                except KeyError:
+                    logger.info("No sharedStrings.xml found in Excel file (this is optional).")
+                except ET.ParseError as e:
+                    logger.error(f"Error parsing sharedStrings.xml: {e}")
+                except Exception as e: # Catch any other unexpected error during sharedStrings parsing
+                    logger.error(f"Unexpected error processing sharedStrings.xml: {e}", exc_info=True)
+            else:
+                return None
+
+            pieces: List[str] = []
+            for member in targets:
+                try:
+                    xml_content = zf.read(member)
+                    xml_root = ET.fromstring(xml_content)
+                    member_texts: List[str] = []
+
+                    if mime_type == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
+                        for cell_element in xml_root.findall(f".//{{{ns_excel_main}}}c"): # Find all <c> elements
+                            value_element = cell_element.find(f"{{{ns_excel_main}}}v") # Find <v> under <c>
+
+                            # Skip if cell has no value element or value element has no text
+                            if value_element is None or value_element.text is None:
+                                continue
+
+                            cell_type = cell_element.get('t')
+                            if cell_type == 's':  # Shared string
+                                try:
+                                    ss_idx = int(value_element.text)
+                                    if 0 <= ss_idx < len(shared_strings):
+                                        member_texts.append(shared_strings[ss_idx])
+                                    else:
+                                        logger.warning(f"Invalid shared string index {ss_idx} in {member}. Max index: {len(shared_strings)-1}")
+                                except ValueError:
+                                    logger.warning(f"Non-integer shared string index: '{value_element.text}' in {member}.")
+                            else:  # Direct value (number, boolean, inline string if not 's')
+                                member_texts.append(value_element.text)
+                    else:  # Word or PowerPoint
+                        for elem in xml_root.iter():
+                            # For Word: <w:t> where w is "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+                            # For PowerPoint: <a:t> where a is "http://schemas.openxmlformats.org/drawingml/2006/main"
+                            if elem.tag.endswith("}t") and elem.text: # Check for any namespaced tag ending with 't'
+                                cleaned_text = elem.text.strip()
+                                if cleaned_text: # Add only if there's non-whitespace text
+                                     member_texts.append(cleaned_text)
+
+                    if member_texts:
+                        pieces.append(" ".join(member_texts)) # Join texts from one member with spaces
+
+                except ET.ParseError as e:
+                    logger.warning(f"Could not parse XML in member '{member}' for {mime_type} file: {e}")
+                except Exception as e:
+                    logger.error(f"Error processing member '{member}' for {mime_type}: {e}", exc_info=True)
+                    # continue processing other members
+
+            if not pieces: # If no text was extracted at all
+                return None
+
+            # Join content from different members (sheets/slides) with double newlines for separation
+            text = "\n\n".join(pieces).strip()
+            return text or None # Ensure None is returned if text is empty after strip
+
+    except zipfile.BadZipFile:
+        logger.warning(f"File is not a valid ZIP archive (mime_type: {mime_type}).")
+        return None
+    except ET.ParseError as e: # Catch parsing errors at the top level if zipfile itself is XML-like
+        logger.error(f"XML parsing error at a high level for {mime_type}: {e}")
+        return None
+    except Exception as e:
+        logger.error(f"Failed to extract office XML text for {mime_type}: {e}", exc_info=True)
+        return None

gcalendar/__init__.py

@@ -0,0 +1 @@
+# Make the calendar directory a Python package

gcalendar/calendar_tools.py

@@ -0,0 +1,496 @@
+"""
+Google Calendar MCP Tools
+
+This module provides MCP tools for interacting with Google Calendar API.
+"""
+
+import datetime
+import logging
+import asyncio
+import os
+import sys
+from typing import List, Optional, Dict, Any
+
+from mcp import types
+from googleapiclient.errors import HttpError
+
+from auth.service_decorator import require_google_service
+
+from core.server import server
+
+
+# Configure module logger
+logger = logging.getLogger(__name__)
+
+
+# Helper function to ensure time strings for API calls are correctly formatted
+def _correct_time_format_for_api(
+    time_str: Optional[str], param_name: str
+) -> Optional[str]:
+    if not time_str:
+        return None
+
+    # Log the incoming time string for debugging
+    logger.info(
+        f"_correct_time_format_for_api: Processing {param_name} with value '{time_str}'"
+    )
+
+    # Handle date-only format (YYYY-MM-DD)
+    if len(time_str) == 10 and time_str.count("-") == 2:
+        try:
+            # Validate it's a proper date
+            datetime.datetime.strptime(time_str, "%Y-%m-%d")
+            # For date-only, append T00:00:00Z to make it RFC3339 compliant
+            formatted = f"{time_str}T00:00:00Z"
+            logger.info(
+                f"Formatting date-only {param_name} '{time_str}' to RFC3339: '{formatted}'"
+            )
+            return formatted
+        except ValueError:
+            logger.warning(
+                f"{param_name} '{time_str}' looks like a date but is not valid YYYY-MM-DD. Using as is."
+            )
+            return time_str
+
+    # Specifically address YYYY-MM-DDTHH:MM:SS by appending 'Z'
+    if (
+        len(time_str) == 19
+        and time_str[10] == "T"
+        and time_str.count(":") == 2
+        and not (
+            time_str.endswith("Z") or ("+" in time_str[10:]) or ("-" in time_str[10:])
+        )
+    ):
+        try:
+            # Validate the format before appending 'Z'
+            datetime.datetime.strptime(time_str, "%Y-%m-%dT%H:%M:%S")
+            logger.info(
+                f"Formatting {param_name} '{time_str}' by appending 'Z' for UTC."
+            )
+            return time_str + "Z"
+        except ValueError:
+            logger.warning(
+                f"{param_name} '{time_str}' looks like it needs 'Z' but is not valid YYYY-MM-DDTHH:MM:SS. Using as is."
+            )
+            return time_str
+
+    # If it already has timezone info or doesn't match our patterns, return as is
+    logger.info(f"{param_name} '{time_str}' doesn't need formatting, using as is.")
+    return time_str
+
+
+@server.tool()
+@require_google_service("calendar", "calendar_read")
+async def list_calendars(service, user_google_email: str) -> str:
+    """
+    Retrieves a list of calendars accessible to the authenticated user.
+
+    Args:
+        user_google_email (str): The user's Google email address. Required.
+
+    Returns:
+        str: A formatted list of the user's calendars (summary, ID, primary status).
+    """
+    logger.info(f"[list_calendars] Invoked. Email: '{user_google_email}'")
+
+    try:
+        calendar_list_response = await asyncio.to_thread(
+            service.calendarList().list().execute
+        )
+        items = calendar_list_response.get("items", [])
+        if not items:
+            return f"No calendars found for {user_google_email}."
+
+        calendars_summary_list = [
+            f"- \"{cal.get('summary', 'No Summary')}\"{' (Primary)' if cal.get('primary') else ''} (ID: {cal['id']})"
+            for cal in items
+        ]
+        text_output = (
+            f"Successfully listed {len(items)} calendars for {user_google_email}:\n"
+            + "\n".join(calendars_summary_list)
+        )
+        logger.info(f"Successfully listed {len(items)} calendars for {user_google_email}.")
+        return text_output
+    except HttpError as error:
+        message = f"API error listing calendars: {error}. You might need to re-authenticate. LLM: Try 'start_google_auth' with user's email and service_name='Google Calendar'."
+        logger.error(message, exc_info=True)
+        raise Exception(message)
+    except Exception as e:
+        message = f"Unexpected error listing calendars: {e}."
+        logger.exception(message)
+        raise Exception(message)
+
+
+@server.tool()
+@require_google_service("calendar", "calendar_read")
+async def get_events(
+    service,
+    user_google_email: str,
+    calendar_id: str = "primary",
+    time_min: Optional[str] = None,
+    time_max: Optional[str] = None,
+    max_results: int = 25,
+) -> str:
+    """
+    Retrieves a list of events from a specified Google Calendar within a given time range.
+
+    Args:
+        user_google_email (str): The user's Google email address. Required.
+        calendar_id (str): The ID of the calendar to query. Use 'primary' for the user's primary calendar. Defaults to 'primary'. Calendar IDs can be obtained using `list_calendars`.
+        time_min (Optional[str]): The start of the time range (inclusive) in RFC3339 format (e.g., '2024-05-12T10:00:00Z' or '2024-05-12'). If omitted, defaults to the current time.
+        time_max (Optional[str]): The end of the time range (exclusive) in RFC3339 format. If omitted, events starting from `time_min` onwards are considered (up to `max_results`).
+        max_results (int): The maximum number of events to return. Defaults to 25.
+
+    Returns:
+        str: A formatted list of events (summary, start time, link) within the specified range.
+    """
+    try:
+        logger.info(
+            f"[get_events] Raw time parameters - time_min: '{time_min}', time_max: '{time_max}'"
+        )
+
+        # Ensure time_min and time_max are correctly formatted for the API
+        formatted_time_min = _correct_time_format_for_api(time_min, "time_min")
+        effective_time_min = formatted_time_min or (
+            datetime.datetime.utcnow().isoformat() + "Z"
+        )
+        if time_min is None:
+            logger.info(
+                f"time_min not provided, defaulting to current UTC time: {effective_time_min}"
+            )
+        else:
+            logger.info(
+                f"time_min processing: original='{time_min}', formatted='{formatted_time_min}', effective='{effective_time_min}'"
+            )
+
+        effective_time_max = _correct_time_format_for_api(time_max, "time_max")
+        if time_max:
+            logger.info(
+                f"time_max processing: original='{time_max}', formatted='{effective_time_max}'"
+            )
+
+        # Log the final API call parameters
+        logger.info(
+            f"[get_events] Final API parameters - calendarId: '{calendar_id}', timeMin: '{effective_time_min}', timeMax: '{effective_time_max}', maxResults: {max_results}"
+        )
+
+        events_result = await asyncio.to_thread(
+            service.events()
+            .list(
+                calendarId=calendar_id,
+                timeMin=effective_time_min,
+                timeMax=effective_time_max,
+                maxResults=max_results,
+                singleEvents=True,
+                orderBy="startTime",
+            )
+            .execute
+        )
+        items = events_result.get("items", [])
+        if not items:
+            return f"No events found in calendar '{calendar_id}' for {user_google_email} for the specified time range."
+
+        event_details_list = []
+        for item in items:
+            summary = item.get("summary", "No Title")
+            start = item["start"].get("dateTime", item["start"].get("date"))
+            link = item.get("htmlLink", "No Link")
+            event_id = item.get("id", "No ID")
+            # Include the event ID in the output so users can copy it for modify/delete operations
+            event_details_list.append(
+                f'- "{summary}" (Starts: {start}) ID: {event_id} | Link: {link}'
+            )
+
+        text_output = (
+            f"Successfully retrieved {len(items)} events from calendar '{calendar_id}' for {user_google_email}:\n"
+            + "\n".join(event_details_list)
+        )
+        logger.info(f"Successfully retrieved {len(items)} events for {user_google_email}.")
+        return text_output
+    except HttpError as error:
+        message = f"API error getting events: {error}. You might need to re-authenticate. LLM: Try 'start_google_auth' with user's email and service_name='Google Calendar'."
+        logger.error(message, exc_info=True)
+        raise Exception(message)
+    except Exception as e:
+        message = f"Unexpected error getting events: {e}"
+        logger.exception(message)
+        raise Exception(message)
+
+
+@server.tool()
+@require_google_service("calendar", "calendar_events")
+async def create_event(
+    service,
+    user_google_email: str,
+    summary: str,
+    start_time: str,
+    end_time: str,
+    calendar_id: str = "primary",
+    description: Optional[str] = None,
+    location: Optional[str] = None,
+    attendees: Optional[List[str]] = None,
+    timezone: Optional[str] = None,
+) -> str:
+    """
+    Creates a new event.
+
+    Args:
+        user_google_email (str): The user's Google email address. Required.
+        summary (str): Event title.
+        start_time (str): Start time (RFC3339, e.g., "2023-10-27T10:00:00-07:00" or "2023-10-27" for all-day).
+        end_time (str): End time (RFC3339, e.g., "2023-10-27T11:00:00-07:00" or "2023-10-28" for all-day).
+        calendar_id (str): Calendar ID (default: 'primary').
+        description (Optional[str]): Event description.
+        location (Optional[str]): Event location.
+        attendees (Optional[List[str]]): Attendee email addresses.
+        timezone (Optional[str]): Timezone (e.g., "America/New_York").
+
+    Returns:
+        str: Confirmation message of the successful event creation with event link.
+    """
+    logger.info(
+        f"[create_event] Invoked. Email: '{user_google_email}', Summary: {summary}"
+    )
+
+    try:
+        event_body: Dict[str, Any] = {
+            "summary": summary,
+            "start": (
+                {"date": start_time}
+                if "T" not in start_time
+                else {"dateTime": start_time}
+            ),
+            "end": (
+                {"date": end_time} if "T" not in end_time else {"dateTime": end_time}
+            ),
+        }
+        if location:
+            event_body["location"] = location
+        if description:
+            event_body["description"] = description
+        if timezone:
+            if "dateTime" in event_body["start"]:
+                event_body["start"]["timeZone"] = timezone
+            if "dateTime" in event_body["end"]:
+                event_body["end"]["timeZone"] = timezone
+        if attendees:
+            event_body["attendees"] = [{"email": email} for email in attendees]
+
+        created_event = await asyncio.to_thread(
+            service.events().insert(calendarId=calendar_id, body=event_body).execute
+        )
+
+        link = created_event.get("htmlLink", "No link available")
+        confirmation_message = f"Successfully created event '{created_event.get('summary', summary)}' for {user_google_email}. Link: {link}"
+        logger.info(
+            f"Event created successfully for {user_google_email}. ID: {created_event.get('id')}, Link: {link}"
+        )
+        return confirmation_message
+    except HttpError as error:
+        message = f"API error creating event: {error}. You might need to re-authenticate. LLM: Try 'start_google_auth' with the user's email ({user_google_email}) and service_name='Google Calendar'."
+        logger.error(message, exc_info=True)
+        raise Exception(message)
+    except Exception as e:
+        message = f"Unexpected error creating event: {e}."
+        logger.exception(message)
+        raise Exception(message)
+
+
+@server.tool()
+@require_google_service("calendar", "calendar_events")
+async def modify_event(
+    service,
+    user_google_email: str,
+    event_id: str,
+    calendar_id: str = "primary",
+    summary: Optional[str] = None,
+    start_time: Optional[str] = None,
+    end_time: Optional[str] = None,
+    description: Optional[str] = None,
+    location: Optional[str] = None,
+    attendees: Optional[List[str]] = None,
+    timezone: Optional[str] = None,
+) -> str:
+    """
+    Modifies an existing event.
+
+    Args:
+        user_google_email (str): The user's Google email address. Required.
+        event_id (str): The ID of the event to modify.
+        calendar_id (str): Calendar ID (default: 'primary').
+        summary (Optional[str]): New event title.
+        start_time (Optional[str]): New start time (RFC3339, e.g., "2023-10-27T10:00:00-07:00" or "2023-10-27" for all-day).
+        end_time (Optional[str]): New end time (RFC3339, e.g., "2023-10-27T11:00:00-07:00" or "2023-10-28" for all-day).
+        description (Optional[str]): New event description.
+        location (Optional[str]): New event location.
+        attendees (Optional[List[str]]): New attendee email addresses.
+        timezone (Optional[str]): New timezone (e.g., "America/New_York").
+
+    Returns:
+        str: Confirmation message of the successful event modification with event link.
+    """
+    logger.info(
+        f"[modify_event] Invoked. Email: '{user_google_email}', Event ID: {event_id}"
+    )
+
+    try:
+        # Build the event body with only the fields that are provided
+        event_body: Dict[str, Any] = {}
+        if summary is not None:
+            event_body["summary"] = summary
+        if start_time is not None:
+            event_body["start"] = (
+                {"date": start_time}
+                if "T" not in start_time
+                else {"dateTime": start_time}
+            )
+            if timezone is not None and "dateTime" in event_body["start"]:
+                event_body["start"]["timeZone"] = timezone
+        if end_time is not None:
+            event_body["end"] = (
+                {"date": end_time} if "T" not in end_time else {"dateTime": end_time}
+            )
+            if timezone is not None and "dateTime" in event_body["end"]:
+                event_body["end"]["timeZone"] = timezone
+        if description is not None:
+            event_body["description"] = description
+        if location is not None:
+            event_body["location"] = location
+        if attendees is not None:
+            event_body["attendees"] = [{"email": email} for email in attendees]
+        if (
+            timezone is not None
+            and "start" not in event_body
+            and "end" not in event_body
+        ):
+            # If timezone is provided but start/end times are not, we need to fetch the existing event
+            # to apply the timezone correctly. This is a simplification; a full implementation
+            # might handle this more robustly or require start/end with timezone.
+            # For now, we'll log a warning and skip applying timezone if start/end are missing.
+            logger.warning(
+                f"[modify_event] Timezone provided but start_time and end_time are missing. Timezone will not be applied unless start/end times are also provided."
+            )
+
+        if not event_body:
+            message = "No fields provided to modify the event."
+            logger.warning(f"[modify_event] {message}")
+            raise Exception(message)
+
+        # Log the event ID for debugging
+        logger.info(
+            f"[modify_event] Attempting to update event with ID: '{event_id}' in calendar '{calendar_id}'"
+        )
+
+        # Try to get the event first to verify it exists
+        try:
+            await asyncio.to_thread(
+                service.events().get(calendarId=calendar_id, eventId=event_id).execute
+            )
+            logger.info(
+                f"[modify_event] Successfully verified event exists before update"
+            )
+        except HttpError as get_error:
+            if get_error.resp.status == 404:
+                logger.error(
+                    f"[modify_event] Event not found during pre-update verification: {get_error}"
+                )
+                message = f"Event not found during verification. The event with ID '{event_id}' could not be found in calendar '{calendar_id}'. This may be due to incorrect ID format or the event no longer exists."
+                raise Exception(message)
+            else:
+                logger.warning(
+                    f"[modify_event] Error during pre-update verification, but proceeding with update: {get_error}"
+                )
+
+        # Proceed with the update
+        updated_event = await asyncio.to_thread(
+            service.events()
+            .update(calendarId=calendar_id, eventId=event_id, body=event_body)
+            .execute
+        )
+
+        link = updated_event.get("htmlLink", "No link available")
+        confirmation_message = f"Successfully modified event '{updated_event.get('summary', summary)}' (ID: {event_id}) for {user_google_email}. Link: {link}"
+        logger.info(
+            f"Event modified successfully for {user_google_email}. ID: {updated_event.get('id')}, Link: {link}"
+        )
+        return confirmation_message
+    except HttpError as error:
+        # Check for 404 Not Found error specifically
+        if error.resp.status == 404:
+            message = f"Event not found. The event with ID '{event_id}' could not be found in calendar '{calendar_id}'. LLM: The event may have been deleted, or the event ID might be incorrect. Verify the event exists using 'get_events' before attempting to modify it."
+            logger.error(f"[modify_event] {message}")
+        else:
+            message = f"API error modifying event (ID: {event_id}): {error}. You might need to re-authenticate. LLM: Try 'start_google_auth' with the user's email ({user_google_email}) and service_name='Google Calendar'."
+            logger.error(message, exc_info=True)
+        raise Exception(message)
+    except Exception as e:
+        message = f"Unexpected error modifying event (ID: {event_id}): {e}."
+        logger.exception(message)
+        raise Exception(message)
+
+
+@server.tool()
+@require_google_service("calendar", "calendar_events")
+async def delete_event(service, user_google_email: str, event_id: str, calendar_id: str = "primary") -> str:
+    """
+    Deletes an existing event.
+
+    Args:
+        user_google_email (str): The user's Google email address. Required.
+        event_id (str): The ID of the event to delete.
+        calendar_id (str): Calendar ID (default: 'primary').
+
+    Returns:
+        str: Confirmation message of the successful event deletion.
+    """
+    logger.info(
+        f"[delete_event] Invoked. Email: '{user_google_email}', Event ID: {event_id}"
+    )
+
+    try:
+        # Log the event ID for debugging
+        logger.info(
+            f"[delete_event] Attempting to delete event with ID: '{event_id}' in calendar '{calendar_id}'"
+        )
+
+        # Try to get the event first to verify it exists
+        try:
+            await asyncio.to_thread(
+                service.events().get(calendarId=calendar_id, eventId=event_id).execute
+            )
+            logger.info(
+                f"[delete_event] Successfully verified event exists before deletion"
+            )
+        except HttpError as get_error:
+            if get_error.resp.status == 404:
+                logger.error(
+                    f"[delete_event] Event not found during pre-delete verification: {get_error}"
+                )
+                message = f"Event not found during verification. The event with ID '{event_id}' could not be found in calendar '{calendar_id}'. This may be due to incorrect ID format or the event no longer exists."
+                raise Exception(message)
+            else:
+                logger.warning(
+                    f"[delete_event] Error during pre-delete verification, but proceeding with deletion: {get_error}"
+                )
+
+        # Proceed with the deletion
+        await asyncio.to_thread(
+            service.events().delete(calendarId=calendar_id, eventId=event_id).execute
+        )
+
+        confirmation_message = f"Successfully deleted event (ID: {event_id}) from calendar '{calendar_id}' for {user_google_email}."
+        logger.info(f"Event deleted successfully for {user_google_email}. ID: {event_id}")
+        return confirmation_message
+    except HttpError as error:
+        # Check for 404 Not Found error specifically
+        if error.resp.status == 404:
+            message = f"Event not found. The event with ID '{event_id}' could not be found in calendar '{calendar_id}'. LLM: The event may have been deleted already, or the event ID might be incorrect."
+            logger.error(f"[delete_event] {message}")
+        else:
+            message = f"API error deleting event (ID: {event_id}): {error}. You might need to re-authenticate. LLM: Try 'start_google_auth' with the user's email ({user_google_email}) and service_name='Google Calendar'."
+            logger.error(message, exc_info=True)
+        raise Exception(message)
+    except Exception as e:
+        message = f"Unexpected error deleting event (ID: {event_id}): {e}."
+        logger.exception(message)
+        raise Exception(message)

gchat/__init__.py

@@ -0,0 +1,6 @@
+"""
+Google Chat MCP Tools Package
+"""
+from . import chat_tools
+
+__all__ = ['chat_tools']