google-workspace-mcp 1.0.5__py3-none-any.whl → 1.2.0__py3-none-any.whl

google_workspace_mcp/tools/gmail.py

@@ -3,9 +3,19 @@ Gmail tools for Google Workspace MCP operations.
 """
 
 import logging
-from typing import Any
 
 from google_workspace_mcp.app import mcp
+from google_workspace_mcp.models import (
+    GmailAttachmentOutput,
+    GmailBulkDeleteOutput,
+    GmailDraftCreationOutput,
+    GmailDraftDeletionOutput,
+    GmailDraftSendOutput,
+    GmailEmailSearchOutput,
+    GmailMessageDetailsOutput,
+    GmailReplyOutput,
+    GmailSendOutput,
+)
 from google_workspace_mcp.services.gmail import GmailService
 
 logger = logging.getLogger(__name__)
@@ -18,7 +28,9 @@ logger = logging.getLogger(__name__)
     name="query_gmail_emails",
     description="Query Gmail emails based on a search query.",
 )
-async def query_gmail_emails(query: str, max_results: int = 100) -> dict[str, Any]:
+async def query_gmail_emails(
+    query: str, max_results: int = 100
+) -> GmailEmailSearchOutput:
     """
     Searches for Gmail emails using Gmail query syntax.
 
@@ -27,7 +39,7 @@ async def query_gmail_emails(query: str, max_results: int = 100) -> dict[str, An
         max_results: Maximum number of emails to return.
 
     Returns:
-        A dictionary containing the list of matching emails or an error message.
+        GmailEmailSearchOutput containing the list of matching emails.
     """
     logger.info(f"Executing query_gmail_emails tool with query: '{query}'")
 
@@ -40,16 +52,16 @@ async def query_gmail_emails(query: str, max_results: int = 100) -> dict[str, An
 
     # Return appropriate message if no results
     if not emails:
-        return {"message": "No emails found for the query."}
+        emails = []
 
-    return {"count": len(emails), "emails": emails}
+    return GmailEmailSearchOutput(count=len(emails), emails=emails)
 
 
 @mcp.tool(
     name="gmail_get_message_details",
     description="Retrieves a complete Gmail email message by its ID.",
 )
-async def gmail_get_message_details(email_id: str) -> dict[str, Any]:
+async def gmail_get_message_details(email_id: str) -> GmailMessageDetailsOutput:
     """
     Retrieves a complete Gmail email message by its ID.
 
@@ -57,7 +69,7 @@ async def gmail_get_message_details(email_id: str) -> dict[str, Any]:
         email_id: The ID of the Gmail message to retrieve.
 
     Returns:
-        A dictionary containing the email details and attachments.
+        GmailMessageDetailsOutput containing the email details and attachments.
     """
     logger.info(f"Executing gmail_get_message_details tool with email_id: '{email_id}'")
     if not email_id or not email_id.strip():
@@ -74,14 +86,25 @@ async def gmail_get_message_details(email_id: str) -> dict[str, Any]:
     if not result:
         raise ValueError(f"Failed to retrieve email with ID: {email_id}")
 
-    return result
+    return GmailMessageDetailsOutput(
+        id=result["id"],
+        thread_id=result.get("thread_id", ""),
+        subject=result.get("subject", ""),
+        from_email=result.get("from_email", ""),
+        to_email=result.get("to_email", []),
+        date=result.get("date", ""),
+        body=result.get("body", ""),
+        attachments=result.get("attachments"),
+    )
 
 
 @mcp.tool(
     name="gmail_get_attachment_content",
     description="Retrieves a specific attachment from a Gmail message.",
 )
-async def gmail_get_attachment_content(message_id: str, attachment_id: str) -> dict[str, Any]:
+async def gmail_get_attachment_content(
+    message_id: str, attachment_id: str
+) -> GmailAttachmentOutput:
     """
     Retrieves a specific attachment from a Gmail message.
 
@@ -90,14 +113,18 @@ async def gmail_get_attachment_content(message_id: str, attachment_id: str) -> d
         attachment_id: The ID of the attachment to retrieve.
 
     Returns:
-        A dictionary containing filename, mimeType, size, and base64 data.
+        GmailAttachmentOutput containing filename, mimeType, size, and base64 data.
     """
-    logger.info(f"Executing gmail_get_attachment_content tool - Msg: {message_id}, Attach: {attachment_id}")
+    logger.info(
+        f"Executing gmail_get_attachment_content tool - Msg: {message_id}, Attach: {attachment_id}"
+    )
     if not message_id or not attachment_id:
         raise ValueError("Message ID and attachment ID are required")
 
     gmail_service = GmailService()
-    result = gmail_service.get_attachment_content(message_id=message_id, attachment_id=attachment_id)
+    result = gmail_service.get_attachment_content(
+        message_id=message_id, attachment_id=attachment_id
+    )
 
     if not result or (isinstance(result, dict) and result.get("error")):
         error_msg = "Error getting attachment"
@@ -105,8 +132,12 @@ async def gmail_get_attachment_content(message_id: str, attachment_id: str) -> d
             error_msg = result.get("message", error_msg)
         raise ValueError(error_msg)
 
-    # FastMCP should handle this dict, recognizing 'data' as content blob.
-    return result
+    return GmailAttachmentOutput(
+        filename=result["filename"],
+        mime_type=result["mime_type"],
+        size=result["size"],
+        data=result["data"],
+    )
 
 
 @mcp.tool(
@@ -119,7 +150,7 @@ async def create_gmail_draft(
     body: str,
     cc: list[str] | None = None,
     bcc: list[str] | None = None,
-) -> dict[str, Any]:
+) -> GmailDraftCreationOutput:
     """
     Creates a draft email message in Gmail.
 
@@ -131,7 +162,7 @@ async def create_gmail_draft(
         bcc: Optional list of email addresses to BCC.
 
     Returns:
-        A dictionary containing the created draft details.
+        GmailDraftCreationOutput containing the created draft details.
     """
     logger.info("Executing create_gmail_draft")
     if not to or not subject or not body:  # Check for empty strings
@@ -139,7 +170,9 @@ async def create_gmail_draft(
 
     gmail_service = GmailService()
     # Pass bcc parameter even though service may not use it (for test compatibility)
-    result = gmail_service.create_draft(to=to, subject=subject, body=body, cc=cc, bcc=bcc)
+    result = gmail_service.create_draft(
+        to=to, subject=subject, body=body, cc=cc, bcc=bcc
+    )
 
     if not result or (isinstance(result, dict) and result.get("error")):
         error_msg = "Error creating draft"
@@ -147,7 +180,7 @@ async def create_gmail_draft(
             error_msg = result.get("message", error_msg)
         raise ValueError(error_msg)
 
-    return result
+    return GmailDraftCreationOutput(id=result["id"], message=result.get("message", {}))
 
 
 @mcp.tool(
@@ -156,7 +189,7 @@ async def create_gmail_draft(
 )
 async def delete_gmail_draft(
     draft_id: str,
-) -> dict[str, Any]:
+) -> GmailDraftDeletionOutput:
     """
     Deletes a specific draft email from Gmail.
 
@@ -164,7 +197,7 @@ async def delete_gmail_draft(
         draft_id: The ID of the draft to delete.
 
     Returns:
-        A dictionary confirming the deletion.
+        GmailDraftDeletionOutput confirming the deletion.
     """
     logger.info(f"Executing delete_gmail_draft with draft_id: '{draft_id}'")
     if not draft_id or not draft_id.strip():
@@ -177,23 +210,24 @@ async def delete_gmail_draft(
         # Attempt to check if the service returned an error dict
         # (Assuming handle_api_error might return dict or False/None)
         # This part might need adjustment based on actual service error handling
-        error_info = getattr(gmail_service, "last_error", None)  # Hypothetical error capture
+        error_info = getattr(
+            gmail_service, "last_error", None
+        )  # Hypothetical error capture
         error_msg = "Failed to delete draft"
         if isinstance(error_info, dict) and error_info.get("error"):
             error_msg = error_info.get("message", error_msg)
         raise ValueError(error_msg)
 
-    return {
-        "message": f"Draft with ID '{draft_id}' deleted successfully.",
-        "success": True,
-    }
+    return GmailDraftDeletionOutput(
+        message=f"Draft with ID '{draft_id}' deleted successfully.", success=True
+    )
 
 
 @mcp.tool(
     name="gmail_send_draft",
     description="Sends an existing draft email from Gmail.",
 )
-async def gmail_send_draft(draft_id: str) -> dict[str, Any]:
+async def gmail_send_draft(draft_id: str) -> GmailDraftSendOutput:
     """
     Sends a specific draft email.
 
@@ -201,7 +235,7 @@ async def gmail_send_draft(draft_id: str) -> dict[str, Any]:
         draft_id: The ID of the draft to send.
 
     Returns:
-        A dictionary containing the details of the sent message or an error.
+        GmailDraftSendOutput containing the details of the sent message.
     """
     logger.info(f"Executing gmail_send_draft tool for draft_id: '{draft_id}'")
     if not draft_id or not draft_id.strip():
@@ -216,7 +250,11 @@ async def gmail_send_draft(draft_id: str) -> dict[str, Any]:
     if not result:  # Should be caught by error dict check
         raise ValueError(f"Failed to send draft '{draft_id}'")
 
-    return result
+    return GmailDraftSendOutput(
+        id=result["id"],
+        thread_id=result.get("thread_id", ""),
+        label_ids=result.get("label_ids", []),
+    )
 
 
 @mcp.tool(
@@ -228,7 +266,7 @@ async def gmail_reply_to_email(
     reply_body: str,
     send: bool = False,
     reply_all: bool = False,
-) -> dict[str, Any]:
+) -> GmailReplyOutput:
     """
     Creates a reply to an existing email thread.
 
@@ -239,7 +277,7 @@ async def gmail_reply_to_email(
         reply_all: If True, reply to all recipients. If False, reply to sender only.
 
     Returns:
-        A dictionary containing the sent message or created draft details.
+        GmailReplyOutput containing the sent message or created draft details.
     """
     logger.info(f"Executing gmail_reply_to_email to message: '{email_id}'")
     if not email_id or not reply_body:
@@ -259,7 +297,9 @@ async def gmail_reply_to_email(
             error_msg = result.get("message", error_msg)
         raise ValueError(error_msg)
 
-    return result
+    return GmailReplyOutput(
+        id=result["id"], thread_id=result.get("thread_id", ""), in_reply_to=email_id
+    )
 
 
 @mcp.tool(
@@ -268,7 +308,7 @@ async def gmail_reply_to_email(
 )
 async def gmail_bulk_delete_messages(
     message_ids: list[str],
-) -> dict[str, Any]:
+) -> GmailBulkDeleteOutput:
     """
     Deletes multiple Gmail emails using a list of message IDs.
 
@@ -276,7 +316,7 @@ async def gmail_bulk_delete_messages(
         message_ids: A list of email message IDs to delete.
 
     Returns:
-        A dictionary summarizing the deletion result.
+        GmailBulkDeleteOutput summarizing the deletion result.
     """
     # Validation first - check if it's a list
     if not isinstance(message_ids, list):
@@ -297,7 +337,13 @@ async def gmail_bulk_delete_messages(
             error_msg = result.get("message", error_msg)
         raise ValueError(error_msg)
 
-    return result
+    return GmailBulkDeleteOutput(
+        deleted_count=result.get("deleted_count", len(message_ids)),
+        success=result.get("success", True),
+        message=result.get(
+            "message", f"Successfully deleted {len(message_ids)} messages"
+        ),
+    )
 
 
 @mcp.tool(
@@ -310,7 +356,7 @@ async def gmail_send_email(
     body: str,
     cc: list[str] | None = None,
     bcc: list[str] | None = None,
-) -> dict[str, Any]:
+) -> GmailSendOutput:
     """
     Composes and sends an email message.
 
@@ -322,14 +368,20 @@ async def gmail_send_email(
         bcc: Optional. A list of BCC recipient email addresses.
 
     Returns:
-        A dictionary containing the details of the sent message or an error.
+        GmailSendOutput containing the details of the sent message.
     """
     logger.info(f"Executing gmail_send_email tool to: {to}, subject: '{subject}'")
-    if not to or not isinstance(to, list) or not all(isinstance(email, str) and email.strip() for email in to):
+    if (
+        not to
+        or not isinstance(to, list)
+        or not all(isinstance(email, str) and email.strip() for email in to)
+    ):
         raise ValueError("Recipients 'to' must be a non-empty list of email strings.")
     if not subject or not subject.strip():
         raise ValueError("Subject cannot be empty.")
-    if body is None:  # Allow empty string for body, but not None if it implies missing arg.
+    if (
+        body is None
+    ):  # Allow empty string for body, but not None if it implies missing arg.
         raise ValueError("Body cannot be None (can be an empty string).")
 
     gmail_service = GmailService()
@@ -341,4 +393,8 @@ async def gmail_send_email(
     if not result:
         raise ValueError("Failed to send email")
 
-    return result
+    return GmailSendOutput(
+        id=result["id"],
+        thread_id=result.get("thread_id", ""),
+        label_ids=result.get("label_ids", []),
+    )

google_workspace_mcp/tools/sheets_tools.py

@@ -6,6 +6,15 @@ import logging
 from typing import Any
 
 from google_workspace_mcp.app import mcp
+from google_workspace_mcp.models import (
+    SheetsAddSheetOutput,
+    SheetsAppendOutput,
+    SheetsClearOutput,
+    SheetsCreationOutput,
+    SheetsDeleteSheetOutput,
+    SheetsReadOutput,
+    SheetsWriteOutput,
+)
 from google_workspace_mcp.services.sheets_service import SheetsService
 
 logger = logging.getLogger(__name__)
@@ -15,7 +24,7 @@ logger = logging.getLogger(__name__)
     name="sheets_create_spreadsheet",
     description="Creates a new Google Spreadsheet with a specified title.",
 )
-async def sheets_create_spreadsheet(title: str) -> dict[str, Any]:
+async def sheets_create_spreadsheet(title: str) -> SheetsCreationOutput:
     """
     Creates a new, empty Google Spreadsheet.
 
@@ -23,8 +32,7 @@ async def sheets_create_spreadsheet(title: str) -> dict[str, Any]:
         title: The title for the new Google Spreadsheet.
 
     Returns:
-        A dictionary containing the 'spreadsheet_id', 'title', and 'spreadsheet_url'
-        of the created spreadsheet, or an error message.
+        SheetsCreationOutput containing the spreadsheet_id, title, and spreadsheet_url.
     """
     logger.info(f"Executing sheets_create_spreadsheet tool with title: '{title}'")
     if not title or not title.strip():
@@ -37,16 +45,22 @@ async def sheets_create_spreadsheet(title: str) -> dict[str, Any]:
         raise ValueError(result.get("message", "Error creating spreadsheet"))
 
     if not result or not result.get("spreadsheet_id"):
-        raise ValueError(f"Failed to create spreadsheet '{title}' or did not receive a spreadsheet ID.")
-
-    return result
+        raise ValueError(
+            f"Failed to create spreadsheet '{title}' or did not receive a spreadsheet ID."
+        )
+
+    return SheetsCreationOutput(
+        spreadsheet_id=result["spreadsheet_id"],
+        title=result["title"],
+        spreadsheet_url=result["spreadsheet_url"],
+    )
 
 
 @mcp.tool(
     name="sheets_read_range",
     description="Reads data from a specified range in a Google Spreadsheet (e.g., 'Sheet1!A1:B5').",
 )
-async def sheets_read_range(spreadsheet_id: str, range_a1: str) -> dict[str, Any]:
+async def sheets_read_range(spreadsheet_id: str, range_a1: str) -> SheetsReadOutput:
     """
     Reads data from a given A1 notation range in a Google Spreadsheet.
 
@@ -56,10 +70,11 @@ async def sheets_read_range(spreadsheet_id: str, range_a1: str) -> dict[str, Any
                   to the first visible sheet or if sheet name is part of it).
 
     Returns:
-        A dictionary containing the range and a list of lists representing the cell values,
-        or an error message.
+        SheetsReadOutput containing the range and cell values.
     """
-    logger.info(f"Executing sheets_read_range tool for spreadsheet_id: '{spreadsheet_id}', range: '{range_a1}'")
+    logger.info(
+        f"Executing sheets_read_range tool for spreadsheet_id: '{spreadsheet_id}', range: '{range_a1}'"
+    )
     if not spreadsheet_id or not spreadsheet_id.strip():
         raise ValueError("Spreadsheet ID cannot be empty.")
     if not range_a1 or not range_a1.strip():
@@ -71,10 +86,18 @@ async def sheets_read_range(spreadsheet_id: str, range_a1: str) -> dict[str, Any
     if isinstance(result, dict) and result.get("error"):
         raise ValueError(result.get("message", "Error reading range from spreadsheet"))
 
-    if not result or "values" not in result:  # Check for 'values' as it's key for successful read
-        raise ValueError(f"Failed to read range '{range_a1}' from spreadsheet '{spreadsheet_id}'.")
-
-    return result
+    if (
+        not result or "values" not in result
+    ):  # Check for 'values' as it's key for successful read
+        raise ValueError(
+            f"Failed to read range '{range_a1}' from spreadsheet '{spreadsheet_id}'."
+        )
+
+    return SheetsReadOutput(
+        range=result.get("range", range_a1),
+        values=result.get("values", []),
+        major_dimension=result.get("major_dimension", "ROWS"),
+    )
 
 
 @mcp.tool(
@@ -86,7 +109,7 @@ async def sheets_write_range(
     range_a1: str,
     values: list[list[Any]],
     value_input_option: str = "USER_ENTERED",
-) -> dict[str, Any]:
+) -> SheetsWriteOutput:
     """
     Writes data (list of lists) to a given A1 notation range in a Google Spreadsheet.
 
@@ -99,10 +122,11 @@ async def sheets_write_range(
                             "USER_ENTERED": Values parsed as if typed by user (e.g., formulas).
                             "RAW": Values taken literally. (Default: "USER_ENTERED")
     Returns:
-        A dictionary detailing the update (updated range, number of cells, etc.),
-        or an error message.
+        SheetsWriteOutput detailing the update.
     """
-    logger.info(f"Executing sheets_write_range tool for spreadsheet_id: '{spreadsheet_id}', range: '{range_a1}'")
+    logger.info(
+        f"Executing sheets_write_range tool for spreadsheet_id: '{spreadsheet_id}', range: '{range_a1}'"
+    )
     if not spreadsheet_id or not spreadsheet_id.strip():
         raise ValueError("Spreadsheet ID cannot be empty.")
     if not range_a1 or not range_a1.strip():
@@ -124,9 +148,16 @@ async def sheets_write_range(
         raise ValueError(result.get("message", "Error writing to range in spreadsheet"))
 
     if not result or not result.get("updated_range"):
-        raise ValueError(f"Failed to write to range '{range_a1}' in spreadsheet '{spreadsheet_id}'.")
-
-    return result
+        raise ValueError(
+            f"Failed to write to range '{range_a1}' in spreadsheet '{spreadsheet_id}'."
+        )
+
+    return SheetsWriteOutput(
+        updated_range=result["updated_range"],
+        updated_rows=result.get("updated_rows", 0),
+        updated_columns=result.get("updated_columns", 0),
+        updated_cells=result.get("updated_cells", 0),
+    )
 
 
 @mcp.tool(
@@ -139,7 +170,7 @@ async def sheets_append_rows(
     values: list[list[Any]],
     value_input_option: str = "USER_ENTERED",
     insert_data_option: str = "INSERT_ROWS",
-) -> dict[str, Any]:
+) -> SheetsAppendOutput:
     """
     Appends rows of data to a sheet or table in a Google Spreadsheet.
 
@@ -152,10 +183,11 @@ async def sheets_append_rows(
         insert_data_option: How new data should be inserted ("INSERT_ROWS" or "OVERWRITE"). Default: "INSERT_ROWS".
 
     Returns:
-        A dictionary detailing the append operation (e.g., range of appended data),
-        or an error message.
+        SheetsAppendOutput detailing the append operation.
     """
-    logger.info(f"Executing sheets_append_rows tool for spreadsheet_id: '{spreadsheet_id}', range: '{range_a1}'")
+    logger.info(
+        f"Executing sheets_append_rows tool for spreadsheet_id: '{spreadsheet_id}', range: '{range_a1}'"
+    )
     if not spreadsheet_id or not spreadsheet_id.strip():
         raise ValueError("Spreadsheet ID cannot be empty.")
     if not range_a1 or not range_a1.strip():
@@ -167,7 +199,9 @@ async def sheets_append_rows(
     if value_input_option not in ["USER_ENTERED", "RAW"]:
         raise ValueError("value_input_option must be either 'USER_ENTERED' or 'RAW'.")
     if insert_data_option not in ["INSERT_ROWS", "OVERWRITE"]:
-        raise ValueError("insert_data_option must be either 'INSERT_ROWS' or 'OVERWRITE'.")
+        raise ValueError(
+            "insert_data_option must be either 'INSERT_ROWS' or 'OVERWRITE'."
+        )
 
     sheets_service = SheetsService()
     result = sheets_service.append_rows(
@@ -182,16 +216,22 @@ async def sheets_append_rows(
         raise ValueError(result.get("message", "Error appending rows to spreadsheet"))
 
     if not result:  # Check for empty or None result as well
-        raise ValueError(f"Failed to append rows to range '{range_a1}' in spreadsheet '{spreadsheet_id}'.")
+        raise ValueError(
+            f"Failed to append rows to range '{range_a1}' in spreadsheet '{spreadsheet_id}'."
+        )
 
-    return result
+    return SheetsAppendOutput(
+        spreadsheet_id=spreadsheet_id,
+        table_range=result.get("table_range", range_a1),
+        updates=result.get("updates", {}),
+    )
 
 
 @mcp.tool(
     name="sheets_clear_range",
     description="Clears values from a specified range in a Google Spreadsheet (e.g., 'Sheet1!A1:B5').",
 )
-async def sheets_clear_range(spreadsheet_id: str, range_a1: str) -> dict[str, Any]:
+async def sheets_clear_range(spreadsheet_id: str, range_a1: str) -> SheetsClearOutput:
     """
     Clears all values from a given A1 notation range in a Google Spreadsheet.
     Note: This usually clears only the values, not formatting.
@@ -201,31 +241,39 @@ async def sheets_clear_range(spreadsheet_id: str, range_a1: str) -> dict[str, An
         range_a1: The A1 notation of the range to clear (e.g., "Sheet1!A1:B5").
 
     Returns:
-        A dictionary confirming the cleared range, or an error message.
+        SheetsClearOutput confirming the cleared range.
     """
-    logger.info(f"Executing sheets_clear_range tool for spreadsheet_id: '{spreadsheet_id}', range: '{range_a1}'")
+    logger.info(
+        f"Executing sheets_clear_range tool for spreadsheet_id: '{spreadsheet_id}', range: '{range_a1}'"
+    )
     if not spreadsheet_id or not spreadsheet_id.strip():
         raise ValueError("Spreadsheet ID cannot be empty.")
     if not range_a1 or not range_a1.strip():
         raise ValueError("Range (A1 notation) cannot be empty.")
 
     sheets_service = SheetsService()
-    result = sheets_service.clear_range(spreadsheet_id=spreadsheet_id, range_a1=range_a1)
+    result = sheets_service.clear_range(
+        spreadsheet_id=spreadsheet_id, range_a1=range_a1
+    )
 
     if isinstance(result, dict) and result.get("error"):
         raise ValueError(result.get("message", "Error clearing range in spreadsheet"))
 
     if not result or not result.get("cleared_range"):
-        raise ValueError(f"Failed to clear range '{range_a1}' in spreadsheet '{spreadsheet_id}'.")
+        raise ValueError(
+            f"Failed to clear range '{range_a1}' in spreadsheet '{spreadsheet_id}'."
+        )
 
-    return result
+    return SheetsClearOutput(
+        cleared_range=result["cleared_range"], spreadsheet_id=spreadsheet_id
+    )
 
 
 @mcp.tool(
     name="sheets_add_sheet",
     description="Adds a new sheet (tab) to an existing Google Spreadsheet.",
 )
-async def sheets_add_sheet(spreadsheet_id: str, title: str) -> dict[str, Any]:
+async def sheets_add_sheet(spreadsheet_id: str, title: str) -> SheetsAddSheetOutput:
     """
     Adds a new sheet with the given title to the specified spreadsheet.
 
@@ -234,10 +282,11 @@ async def sheets_add_sheet(spreadsheet_id: str, title: str) -> dict[str, Any]:
         title: The title for the new sheet.
 
     Returns:
-        A dictionary containing properties of the newly created sheet (like sheetId, title, index),
-        or an error message.
+        SheetsAddSheetOutput containing properties of the newly created sheet.
     """
-    logger.info(f"Executing sheets_add_sheet tool for spreadsheet_id: '{spreadsheet_id}', title: '{title}'")
+    logger.info(
+        f"Executing sheets_add_sheet tool for spreadsheet_id: '{spreadsheet_id}', title: '{title}'"
+    )
     if not spreadsheet_id or not spreadsheet_id.strip():
         raise ValueError("Spreadsheet ID cannot be empty.")
     if not title or not title.strip():
@@ -250,16 +299,22 @@ async def sheets_add_sheet(spreadsheet_id: str, title: str) -> dict[str, Any]:
         raise ValueError(result.get("message", "Error adding sheet to spreadsheet"))
 
     if not result or not result.get("sheet_properties"):
-        raise ValueError(f"Failed to add sheet '{title}' to spreadsheet '{spreadsheet_id}'.")
+        raise ValueError(
+            f"Failed to add sheet '{title}' to spreadsheet '{spreadsheet_id}'."
+        )
 
-    return result
+    return SheetsAddSheetOutput(
+        sheet_properties=result["sheet_properties"], spreadsheet_id=spreadsheet_id
+    )
 
 
 @mcp.tool(
     name="sheets_delete_sheet",
     description="Deletes a specific sheet (tab) from a Google Spreadsheet using its numeric sheet ID.",
 )
-async def sheets_delete_sheet(spreadsheet_id: str, sheet_id: int) -> dict[str, Any]:
+async def sheets_delete_sheet(
+    spreadsheet_id: str, sheet_id: int
+) -> SheetsDeleteSheetOutput:
     """
     Deletes a sheet from the specified spreadsheet using its numeric ID.
 
@@ -268,21 +323,32 @@ async def sheets_delete_sheet(spreadsheet_id: str, sheet_id: int) -> dict[str, A
         sheet_id: The numeric ID of the sheet to delete.
 
     Returns:
-        A dictionary confirming the deletion or an error message.
+        SheetsDeleteSheetOutput confirming the deletion.
     """
-    logger.info(f"Executing sheets_delete_sheet tool for spreadsheet_id: '{spreadsheet_id}', sheet_id: {sheet_id}")
+    logger.info(
+        f"Executing sheets_delete_sheet tool for spreadsheet_id: '{spreadsheet_id}', sheet_id: {sheet_id}"
+    )
     if not spreadsheet_id or not spreadsheet_id.strip():
         raise ValueError("Spreadsheet ID cannot be empty.")
     if not isinstance(sheet_id, int):
         raise ValueError("Sheet ID must be an integer.")
 
     sheets_service = SheetsService()
-    result = sheets_service.delete_sheet(spreadsheet_id=spreadsheet_id, sheet_id=sheet_id)
+    result = sheets_service.delete_sheet(
+        spreadsheet_id=spreadsheet_id, sheet_id=sheet_id
+    )
 
     if isinstance(result, dict) and result.get("error"):
         raise ValueError(result.get("message", "Error deleting sheet from spreadsheet"))
 
     if not result or not result.get("success"):
-        raise ValueError(f"Failed to delete sheet ID '{sheet_id}' from spreadsheet '{spreadsheet_id}'.")
+        raise ValueError(
+            f"Failed to delete sheet ID '{sheet_id}' from spreadsheet '{spreadsheet_id}'."
+        )
 
-    return result
+    return SheetsDeleteSheetOutput(
+        success=result["success"],
+        message=result.get("message", f"Sheet ID '{sheet_id}' deleted successfully"),
+        spreadsheet_id=spreadsheet_id,
+        deleted_sheet_id=sheet_id,
+    )