Google Workspace MCP by taylorwilsdon

Appends rows to a structured table in a Google Sheet. The rows are added to the end of the table body, automatically extending the table range.

Use list_sheet_tables first to find the table ID.

Adds or removes labels from multiple Gmail messages in a single batch request.

Executes multiple low-level document operations in a single atomic batch update.

For normal header/footer text, prefer update_doc_headers_footers. Only use create_header_footer here for advanced section-break layouts.

RECOMMENDED WORKFLOW FOR BUILDING DOCUMENTS: ============================================= To avoid index calculation errors, build documents in phases:

PHASE 1 - INSERT ALL CONTENT (use end_of_segment=true, no index math): Append text, section breaks, and page breaks sequentially. Each operation appends to the end of the body. No index needed. Example batch: [ {"type": "insert_text", "end_of_segment": true, "text": "Report Title\n"}, {"type": "insert_text", "end_of_segment": true, "text": "\nExecutive Summary\n"}, {"type": "insert_text", "end_of_segment": true, "text": "Revenue grew 15%.\n"}, {"type": "insert_section_break", "end_of_segment": true, "section_type": "NEXT_PAGE"}, {"type": "insert_text", "end_of_segment": true, "text": "Detailed Analysis\n"} ]

PHASE 2 - CREATE HEADERS/FOOTERS (if needed): For normal header/footer text, use update_doc_headers_footers (it auto-creates if missing and writes the content for you). Only include create_header_footer operations in a batch when you are intentionally managing advanced section-break-specific layouts.

PHASE 3 - INSPECT STRUCTURE: Call inspect_doc_structure with detailed=true to get exact start_index and end_index for every paragraph and element.

PHASE 4 - APPLY FORMATTING (separate batch using indices from Phase 3): Use the real indices from inspect_doc_structure output: [ {"type": "update_paragraph_style", "start_index": 1, "end_index": 15, "heading_level": 1, "alignment": "CENTER"}, {"type": "format_text", "start_index": 1, "end_index": 15, "bold": true, "font_size": 24}, {"type": "create_bullet_list", "start_index": 50, "end_index": 120, "list_type": "ORDERED"} ]

ALTERNATIVE - FIND_REPLACE PATTERN (no indices needed at all): Insert text with unique placeholders, then use find_replace: [ {"type": "insert_text", "end_of_segment": true, "text": "{{TITLE}}\n{{BODY}}\n"}, {"type": "find_replace", "find_text": "{{TITLE}}", "replace_text": "Quarterly Report"}, {"type": "find_replace", "find_text": "{{BODY}}", "replace_text": "The results show..."} ]

WARNING - AVOID THIS ANTI-PATTERN: Do NOT pre-compute sequential indices for multiple insert_text operations. Each insertion shifts all subsequent indices and manual calculation is error-prone. Use end_of_segment=true instead, which always appends to the current end. BAD: [{"type":"insert_text","index":1,"text":"Hello\n"}, {"type":"insert_text","index":8,"text":"World\n"}] <- index 8 may be wrong GOOD: [{"type":"insert_text","end_of_segment":true,"text":"Hello\n"}, {"type":"insert_text","end_of_segment":true,"text":"World\n"}]

Args: user_google_email: User's Google email address document_id: ID of the document to update operations: List of operation dicts. Each operation MUST have a 'type' field. All operations accept an optional 'tab_id' to target a specific tab.

Supported operation types and their parameters:

insert_text - required: text (str) PREFERRED: end_of_segment (bool) - set true to append at end of body without calculating an index. Safest way to build documents sequentially. optional: index (int), tab_id, segment_id delete_text - required: start_index (int), end_index (int) optional: tab_id, segment_id replace_text - required: start_index (int), end_index (int), text (str) optional: tab_id, segment_id format_text - required: start_index (int), end_index (int) optional: bold, italic, underline, strikethrough, font_size, font_family, font_weight, text_color, background_color, link_url, clear_link, baseline_offset, small_caps, tab_id, segment_id update_paragraph_style

• required: start_index (int), end_index (int) optional: heading_level (0-6, 0=normal), alignment (START/CENTER/END/JUSTIFIED), line_spacing, indent_first_line, indent_start, indent_end, space_above, space_below, named_style_type, direction, keep_lines_together, keep_with_next, avoid_widow_and_orphan, page_break_before, spacing_mode, shading_color, tab_id, segment_id update_table_cell_style
• required: table_start_index (int) optional: background_color, border_color, border_width, padding_top, padding_bottom, padding_left, padding_right (float, points), content_alignment ("TOP"|"MIDDLE"|"BOTTOM"), row_index, column_index, row_span, column_span Use inspect_doc_structure to find table_start_index from table_details[].start_index. If row/column values are omitted, the style is applied to the entire table. insert_table - required: rows (int), columns (int) optional: index (int), tab_id, segment_id, end_of_segment insert_table_row - required: table_start_index (int), row_index (int) optional: insert_below (bool, default true), tab_id delete_table_row - required: table_start_index (int), row_index (int) optional: tab_id insert_table_column
• required: table_start_index (int), column_index (int) optional: insert_right (bool, default true), tab_id delete_table_column
• required: table_start_index (int), column_index (int) optional: tab_id merge_table_cells
• required: table_start_index (int), row_index (int), column_index (int), row_span (int), column_span (int) optional: tab_id unmerge_table_cells
• required: table_start_index (int), row_index (int), column_index (int), row_span (int), column_span (int) optional: tab_id update_table_column_properties
• required: table_start_index (int), column_indices (list[int]) optional: width (float, points), width_type (FIXED_WIDTH|EVENLY_DISTRIBUTED), tab_id update_table_row_style
• required: table_start_index (int), row_indices (list[int]) optional: min_row_height (float, points), tab_id pin_table_header_rows
• required: table_start_index (int), pinned_header_rows_count (int) optional: tab_id Set pinned_header_rows_count=1 to repeat the first row as a header across page breaks (0 unpins all rows). This is the writable request for the tableHeader state reported in TableRowStyle. insert_page_break- optional: index (int), end_of_segment, tab_id insert_section_break
• optional: index (int), end_of_segment, section_type ('CONTINUOUS'|'NEXT_PAGE') find_replace - required: find_text (str), replace_text (str) optional: match_case (bool, default false) create_bullet_list - required: start_index (int), end_index (int) optional: list_type ('UNORDERED'|'ORDERED'|'CHECKBOX'|'NONE', default UNORDERED), nesting_level (0-8), paragraph_start_indices (list[int]), bullet_preset Use list_type='NONE' to remove existing bullet/list formatting create_named_range
• required: name (str), start_index (int), end_index (int) optional: tab_id, segment_id replace_named_range_content
• required: text (str) optional: named_range_id, named_range_name, tab_id delete_named_range
• optional: named_range_id, named_range_name, tab_id update_document_style
• optional: background_color, margin_top, margin_bottom, margin_left, margin_right, margin_header, margin_footer, page_width, page_height, page_number_start, use_even_page_header_footer, use_first_page_header_footer, flip_page_orientation, document_mode, tab_id update_section_style
• required: start_index (int), end_index (int) optional: margin_top, margin_bottom, margin_left, margin_right, margin_header, margin_footer, page_number_start, use_first_page_header_footer, flip_page_orientation, content_direction, column_count, column_spacing, column_separator_style create_header_footer
• required: section_type ('header'|'footer') optional: header_footer_type, section_break_index Advanced only. For ordinary header/footer text, use update_doc_headers_footers instead. insert_image - required: image_uri (str) optional: index, width, height, tab_id, segment_id, end_of_segment insert_doc_tab - required: title (str), index (int) optional: parent_tab_id (str) delete_doc_tab - required: tab_id (str) update_doc_tab - required: tab_id (str), title (str)

Example - Safe document building (no index calculation needed): [ {"type": "insert_text", "end_of_segment": true, "text": "Quarterly Report\n\n"}, {"type": "insert_text", "end_of_segment": true, "text": "Executive Summary\n"}, {"type": "insert_text", "end_of_segment": true, "text": "Revenue grew 15% YoY.\n"} ]

Example - Formatting (use exact indices from inspect_doc_structure output): [ {"type": "format_text", "start_index": 1, "end_index": 19, "bold": true, "font_size": 24}, {"type": "update_paragraph_style", "start_index": 1, "end_index": 19, "heading_level": 1, "alignment": "CENTER"}, {"type": "update_paragraph_style", "start_index": 20, "end_index": 39, "heading_level": 2} ]

Example - Using find_replace (zero index risk): [ {"type": "find_replace", "find_text": "{{DATE}}", "replace_text": "March 2026"}, {"type": "find_replace", "find_text": "{{AUTHOR}}", "replace_text": "Jane Smith"} ]

Example - Insert table at end of document: [{"type": "insert_table", "end_of_segment": true, "rows": 3, "columns": 4}]

Example - Headers, footers, and document style: [ {"type": "create_header_footer", "section_type": "header"}, {"type": "create_header_footer", "section_type": "footer"}, {"type": "update_document_style", "margin_top": 72, "margin_bottom": 72} ]

Returns: str: Confirmation message with batch results and document length for chaining

Apply batch updates to a Google Form.

Supports adding, updating, and deleting form items, as well as updating form metadata and settings. This is the primary method for modifying form content after creation.

Apply batch updates to a Google Slides presentation.

Searches for a file by name and checks if it has public link sharing enabled.

Creates a copy of an existing Google Drive file.

This tool copies the template document to a new location with an optional new name. The copy maintains all formatting and content from the original file.

Creates a new secondary Google Calendar.

Creates a new Google Doc and optionally inserts initial content.

After creation, the document body starts at index 1. A new empty doc has total length 2 (one section break at index 0, one newline at index 1).

To build a rich document after creation, use batch_update_doc with insert_text operations using end_of_segment=true to append content sequentially without calculating indices. Then call inspect_doc_structure to get exact positions before applying formatting in a separate batch call.

Creates a new file in Google Drive, supporting creation within shared drives. Accepts direct text content, inline base64 bytes, or a fileUrl to fetch content from.

Creates a new folder in Google Drive, supporting creation within shared drives.

Create a new form using the title given in the provided form message in the request.

Create a new Google Slides presentation.

Adds an emoji reaction to a Google Chat message.

Creates a new Apps Script project.

Creates a new sheet or duplicates an existing sheet (user_google_email: str, spreadsheet_id: str, sheet_name: Optional[str] = None, source_sheet_name: Optional[str] = None, insert_sheet_index: Optional[int] = None).

Creates a new Google Spreadsheet.

Creates a table and populates it with data in one reliable operation.

CRITICAL: YOU MUST CALL inspect_doc_structure FIRST TO GET THE INDEX!

MANDATORY WORKFLOW - DO THESE STEPS IN ORDER:

Step 1: ALWAYS call inspect_doc_structure first Step 2: Use the 'total_length' value from inspect_doc_structure as your index Step 3: Format data as 2D list: [["col1", "col2"], ["row1col1", "row1col2"]] Step 4: Call this function with the correct index and data

EXAMPLE DATA FORMAT: table_data = [ ["Header1", "Header2", "Header3"], # Row 0 - headers ["Data1", "Data2", "Data3"], # Row 1 - first data row ["Data4", "Data5", "Data6"] # Row 2 - second data row ]

CRITICAL INDEX REQUIREMENTS:

• NEVER use index values like 1, 2, 10 without calling inspect_doc_structure first
• ALWAYS get index from inspect_doc_structure 'total_length' field
• Index must be a valid insertion point in the document

DATA FORMAT REQUIREMENTS:

• Must be 2D list of strings only
• Each inner list = one table row
• All rows MUST have same number of columns
• Use empty strings "" for empty cells, never None
• Use debug_table_structure after creation to verify results

Args: user_google_email: User's Google email address document_id: ID of the document to update table_data: 2D list of strings - EXACT format: [["col1", "col2"], ["row1col1", "row1col2"]] index: Document position (MANDATORY: get from inspect_doc_structure 'total_length') bold_headers: Whether to make first row bold (default: true) tab_id: Optional tab ID to create the table in a specific tab header_rows: Number of leading rows to mark as a repeating header that reappears after each page break. Must be between 0 and the number of table rows (default: 0 = none)

Returns: str: Confirmation with table details and link

Creates a new immutable version of a script project.

Versions capture a snapshot of the current script code. Once created, versions cannot be modified.

Return runtime/source information for diagnosing stale MCP server instances.

This is a temporary diagnostic tool intended to verify which code checkout the running MCP server has loaded.

ESSENTIAL DEBUGGING TOOL - Use this whenever tables don't work as expected.

USE THIS IMMEDIATELY WHEN:

• Table population put data in wrong cells
• You get "table not found" errors
• Data appears concatenated in first cell
• Need to understand existing table structure
• Planning to use populate_existing_table

WHAT THIS SHOWS YOU:

• Exact table dimensions (rows × columns)
• Each cell's position coordinates (row,col)
• Current content in each cell
• Insertion indices for each cell
• Table boundaries and ranges

HOW TO READ THE OUTPUT:

• "dimensions": "2x3" = 2 rows, 3 columns
• "position": "(0,0)" = first row, first column
• "current_content": What's actually in each cell right now
• "insertion_index": Where new text would be inserted in that cell

WORKFLOW INTEGRATION:

1. After creating table → Use this to verify structure
2. Before populating → Use this to plan your data format
3. After population fails → Use this to see what went wrong
4. When debugging → Compare your data array to actual table structure

Args: user_google_email: User's Google email address document_id: ID of the document to inspect table_index: Which table to debug (0 = first table, 1 = second table, etc.)

Returns: str: Detailed JSON structure showing table layout, cell positions, and current content

Deletes an Apps Script project.

This permanently deletes the script project. The action cannot be undone.

Downloads an attachment from a Google Chat message and saves it to local disk.

In stdio mode, returns the local file path for direct access. In HTTP mode, returns a temporary download URL (valid for 1 hour).

Creates a draft email in the user's Gmail account. Supports both new drafts and reply drafts with optional attachments. Supports Gmail's "Send As" feature to draft from configured alias addresses.

Exports a Google Doc to PDF format and saves it to Google Drive.

Finds and replaces text throughout a Google Doc. No index calculation required.

This is the safest way to update specific text in a document because it does not require knowing any indices. Use this tool when you need to:

• Replace placeholder text (e.g., {{TITLE}}) with real content
• Update specific words or phrases throughout the document
• Make targeted text changes without risk of index errors

For building documents from scratch, consider inserting text with unique placeholders via batch_update_doc, then using this tool to replace them.

Applies formatting to a range: colors, number formats, text wrapping, alignment, and text styling.

Colors accept hex strings (#RRGGBB). Number formats follow Sheets types (e.g., NUMBER, CURRENCY, DATE, PERCENT). If no sheet name is provided, the first sheet is used.

Generates Apps Script code for creating triggers.

The Apps Script API cannot create triggers directly - they must be created from within Apps Script itself. This tool generates the code you need.

Get detailed information about a specific contact.

Get details of a specific contact group including its members.

Reads a Google Doc and returns it as clean Markdown with optional comment context.

Unlike get_doc_content which returns plain text, this tool preserves document formatting as Markdown: headings, bold/italic/strikethrough, links, code spans, ordered/unordered lists with nesting, and tables.

When comments are included (the default), each comment's anchor text — the specific text the comment was attached to — is preserved, giving full context for the discussion.

Retrieves content of a Google Doc or a Drive file (like .docx) identified by document_id.

• Native Google Docs: Fetches content via Docs API.
• Office files (.docx, etc.) stored in Drive: Downloads via Drive API and extracts text.

Retrieves the content of a specific Google Drive file by ID, supporting files in shared drives.

• Native Google Docs, Sheets, Slides → exported as text / CSV.
• Office files (.docx, .xlsx, .pptx) → unzipped & parsed with std-lib to extract readable text.
• PDFs → text extracted with pypdf when possible; scanned/image-only PDFs fall back to a download hint.
• Images → returned as base64 with MIME metadata for multimodal clients.
• Any other file → downloaded; tries UTF-8 decode, else notes binary.

Downloads a Google Drive file and saves it to local disk.

In stdio mode, returns the local file path for direct access. In HTTP mode, returns a temporary download URL (valid for 1 hour).

For Google native files (Docs, Sheets, Slides), exports to a useful format:

• Google Docs -> PDF (default) or DOCX if export_format='docx'
• Google Sheets -> XLSX (default), PDF if export_format='pdf', or CSV if export_format='csv'
• Google Slides -> PDF (default) or PPTX if export_format='pptx'

For other files, downloads the original file format.

Gets detailed metadata about a Google Drive file including sharing permissions, parent folder IDs, ownership, and lifecycle timestamps.

Gets the shareable link for a Google Drive file or folder.

Retrieves events from a specified Google Calendar. Can retrieve a single event by ID or multiple events within a time range. You can also search for events by keyword by supplying the optional "query" param.

Get a form.

Get one response from the form.

Downloads an email attachment and saves it to local disk.

In stdio mode, returns the local file path for direct access. In HTTP mode, returns a temporary download URL (valid for 1 hour). May re-fetch message metadata to resolve filename and MIME type.

Retrieves the full content (subject, sender, recipients, body) of a specific Gmail message.

Bodies are returned inline and truncated at 20,000 characters. Set full=True to get the complete, untruncated message instead: it is exported to disk and the response carries a short-lived download URL (HTTP transport) or file path (stdio transport) rather than the body, so large messages never stream through the model context. Stateless deployments have no file storage, so there full=True returns the untruncated body inline.

Retrieves the content of multiple Gmail messages in a single batch request. Supports up to 25 messages per batch to prevent SSL connection exhaustion.

Retrieves the complete content of a Gmail conversation thread, including all messages.

Optionally also returns structured ownership analysis so a caller can determine who sent the last message and who owes whom a response without re-parsing the formatted string or making a second tool call.

Retrieves the content of multiple Gmail threads in a single batch request. Supports up to 25 threads per batch to prevent SSL connection exhaustion.

Retrieves messages from a Google Chat space.

Get details about a specific page (slide) in a presentation.

Generate a thumbnail URL for a specific page (slide) in a presentation.

Get details about a Google Slides presentation.

Retrieves content of a specific file within a project.

Gets execution metrics for a script project.

Returns analytics data including active users, total executions, and failed executions over time.

Retrieves complete project details including all source files.

Retrieves metadata about a Programmable Search Engine.

Gets information about a specific spreadsheet including its sheets.

Get details of a specific task.

Get details of a specific task list.

Gets details of a specific version.

Imports a file (Markdown, DOCX, TXT, HTML, RTF, ODT) into Google Docs format with automatic conversion.

Google Drive automatically converts the source file to native Google Docs format, preserving formatting like headings, lists, bold, italic, etc. For batch operations, prefer file_path for files on disk so callers do not need to load full file contents into their context.

Imports a spreadsheet (XLSX, XLS, ODS, CSV, TSV) into Google Sheets format with automatic conversion.

Google Drive automatically converts the source spreadsheet to native Google Sheets format, preserving rows, columns, sheets, and values. For batch operations, prefer file_path for files on disk so callers do not need to load full file contents into their context.

Imports a presentation (PPTX, PPT, ODP) into Google Slides format with automatic conversion.

Google Drive automatically converts the source presentation to native Google Slides format, preserving slides, layouts, text, and images. For batch operations, prefer file_path for files on disk so callers do not need to load full file contents into their context.

Inserts structural elements like tables, lists, or page breaks into a Google Doc.

Inserts an image into a Google Doc from Drive or a URL.

Essential tool for finding safe insertion points and understanding document structure.

USE THIS FOR:

• Finding the correct index for table insertion
• Understanding document layout before making changes
• Locating existing tables and their positions
• Getting document statistics and complexity info
• Inspecting structure of specific tabs

CRITICAL FOR TABLE OPERATIONS: ALWAYS call this BEFORE creating tables to get a safe insertion index.

WHAT THE OUTPUT SHOWS:

• total_elements: Number of document elements
• total_length: Maximum safe index for insertion
• tables: Number of existing tables
• table_details: Position and dimensions of each table
• headers / footers: Real segment IDs and previews for header/footer editing
• tabs: List of available tabs in the document (if no tab_id specified)

WORKFLOW FOR TABLE INSERTION: Step 1: Call this function Step 2: Note the "total_length" value Step 3: Use an index < total_length for table insertion Step 4: Create your table

FORMATTING WORKFLOW: After inserting all text via batch_update_doc with end_of_segment=true, call this tool with detailed=true to get exact start_index and end_index for every paragraph. Use those indices directly in format_text and update_paragraph_style operations in a second batch_update_doc call.

HEADER/FOOTER WORKFLOW: For ordinary header/footer text, use update_doc_headers_footers. If you need low-level segment editing, call this tool first and use the real segment_id values returned under headers/footers. Do not invent IDs.

The detailed output includes elements[].start_index and elements[].end_index with text_preview for each paragraph, making it easy to identify which ranges to format.

Args: user_google_email: User's Google email address document_id: ID of the document to inspect detailed: Whether to return detailed structure information tab_id: Optional ID of the tab to inspect. If not provided, inspects main document.

Returns: str: JSON string containing document structure and safe insertion indices

Retrieves a list of calendars accessible to the authenticated user.

List contact groups (labels) for the user.

List contacts for the authenticated user.

Lists all deployments for a script project.

Lists Google Docs within a specific Drive folder.

Returns: str: A formatted list of Google Docs in the specified folder.

List all comments from a Google Document (optional max_comments to limit results).

Lists files/folders or shared drive containers, supporting shared drives. If drive_id is specified, lists items within that shared drive. folder_id is then relative to that drive (or use drive_id as folder_id for root). If drive_id is not specified, lists items from user's "My Drive" and accessible shared drives (if include_items_from_all_drives is True). Set resource_type to "shared_drives" to list shared drive containers instead of folder contents.

List a form's responses.

Lists all Gmail filters configured in the user's mailbox.

Lists all labels in the user's Gmail account.

List all comments from a Google Presentation (optional max_comments to limit results).

Lists recent execution processes for user's scripts.

Lists Google Apps Script projects accessible to the user.

Uses Drive API to find Apps Script files.

Lists all structured tables in a spreadsheet with their IDs, names, ranges, and column details. Use this to find table IDs for append_table_rows.

Lists Google Chat spaces (rooms and direct messages) accessible to the user.

Returns: str: A formatted list of Google Chat spaces accessible to the user.

List all comments from a Google Spreadsheet (optional max_comments to limit results).

Lists spreadsheets from Google Drive that the user has access to.

List all task lists for the user.

List all tasks in a specific task list.

Lists all versions of a script project.

Versions are immutable snapshots of your script code. They are created when you deploy or explicitly create a version.

Manages conditional formatting rules on a Google Sheet. Supports adding, updating, and deleting conditional formatting rules via a single tool.

Create, update, or delete a contact. Consolidated tool replacing create_contact, update_contact, and delete_contact.

Create, update, delete a contact group, or modify its members. Consolidated tool replacing create_contact_group, update_contact_group, delete_contact_group, and modify_contact_group_members.

Batch create, update, or delete contacts. Consolidated tool replacing batch_create_contacts, batch_update_contacts, and batch_delete_contacts.

Manages Apps Script deployments. Supports creating, updating, and deleting deployments.

Manage document tabs: create, rename, delete, or populate from Markdown.

Manage comments on a Google Document.

Actions:

• create: Create a new document-level comment. Requires comment_content. Note: The Drive API cannot anchor comments to specific text; only the Google Docs UI can do that.
• reply: Reply to a comment. Requires comment_id and comment_content.
• resolve: Resolve a comment. Requires comment_id.

Consolidated tool for managing Google Drive file and folder access permissions.

Supports granting, batch-granting, updating, revoking permissions, and transferring file ownership -- all through a single entry point.

Manages calendar events. Supports creating, updating, deleting, and RSVP.

Manages Focus Time events on Google Calendar. These special events auto-decline meeting invitations and, by default, set the user's chat status to Do Not Disturb, helping protect blocks of uninterrupted work time.

Manages Gmail filters. Supports creating and deleting filters.

Manages Gmail labels: create, update, or delete labels.

Manages Out of Office events on Google Calendar. These special events auto-decline meeting invitations and set the user's status to "Out of office" across Google Workspace.

Manage comments on a Google Presentation.

Actions:

• create: Create a new comment. Requires comment_content. Note: The Drive API cannot anchor comments to arbitrary text; Slides comments are element-scoped via the API.
• reply: Reply to a comment. Requires comment_id and comment_content.
• resolve: Resolve a comment. Requires comment_id.

Manage comments on a Google Spreadsheet.

Actions:

• create: Create a new comment. Requires comment_content. Note: The Drive API cannot anchor comments to arbitrary text; Sheets comments are cell-scoped via the API.
• reply: Reply to a comment. Requires comment_id and comment_content.
• resolve: Resolve a comment. Requires comment_id.

Manage tasks: create, update, delete, or move tasks within task lists.

Manage task lists: create, update, delete, or clear completed tasks.

Modifies text in a Google Doc - can insert/replace text and/or apply formatting in a single operation.

TIP: To append text to the end of the document without calculating indices, set end_of_segment=true. This avoids index calculation errors.

For ordinary header/footer text, prefer update_doc_headers_footers. Only pass segment_id when you already have a real header/footer/footnote segment ID from inspect_doc_structure output. Do not guess IDs such as "kix.header" or "kix.footer".

Adds or removes labels from a Gmail message. To archive an email, remove the INBOX label. To delete an email, add the TRASH label.

Modifies values in a specific range of a Google Sheet - can write, update, or clear values.

Moves rows from one sheet to another within the same spreadsheet. The move is performed in a single batchUpdate (copyPaste followed by deleteDimension). Note: batchUpdate executes requests sequentially but does not roll back on partial failure — if the copy succeeds but the delete fails, rows may be duplicated. Formulas, data types, and formatting are preserved (unlike a values.get/append round-trip). Row numbers are 1-based (matching the spreadsheet UI).

Returns free/busy information for a set of calendars.

Reads values from a specific range in a Google Sheet.

Manages sheet-level dimension properties: resize columns/rows, auto-resize to fit content, freeze rows/columns, hide/unhide rows/columns, and insert/delete rows/columns.

Executes a function in a deployed script.

Search contacts by name, email, phone number, or other fields.

Performs a search using Google Custom Search JSON API.

Searches for Google Docs by name using Drive API (mimeType filter).

Returns: str: A formatted list of Google Docs matching the search query.

Searches for files and folders within a user's Google Drive, including shared drives.

Searches messages in a user's Gmail account based on a query. Returns both Message IDs and Thread IDs for each found message, along with Gmail web interface links for manual verification. Supports pagination via page_token parameter.

Searches for messages in Google Chat spaces by text content and/or time range.

Sends an email using the user's Gmail account. Supports new emails, replies, and forwards, with optional attachments. Supports Gmail's "Send As" feature to send from configured alias addresses.

To forward an existing message, pass forward_message_id. The original subject, body (quoted with a "Forwarded message" header), and attachments are carried over. In forward mode, body (if any) is prepended as a note and subject is optional. Threading, reply, and signature options do not apply when forwarding.

Sends a message to a Google Chat space.

Sets file-level sharing settings and controls link sharing for a Google Drive file or folder.

This is a high-level tool for the most common permission changes. Use this to toggle "anyone with the link" access or configure file-level sharing behavior. For managing individual user/group permissions, use share_drive_file or update_drive_permission instead.

Updates the publish settings of a form.

Manually initiate Google OAuth authentication flow.

NOTE: This is a legacy OAuth 2.0 tool and is disabled when OAuth 2.1 is enabled. The authentication system automatically handles credential checks and prompts for authentication when needed. Only use this tool if:

1. You need to re-authenticate with different credentials
2. You want to proactively authenticate before using other tools
3. The automatic authentication flow failed and you need to retry

In most cases, simply try calling the Google Workspace tool you need - it will automatically handle authentication if required.

Safely creates or updates header/footer text in a Google Doc.

This is the default tool for header/footer content. Do NOT use batch_update_doc with create_header_footer just to set header/footer text; that low-level operation is only for advanced section-break workflows and can fail when the default header/footer already exists.

This tool handles both creation and update in one call:

• If the header/footer does not exist, it is automatically created first.
• If the header/footer already exists, its content is replaced.

You do NOT need to create a header/footer separately before calling this tool. Simply call it with the desired content and it will work whether the header/footer exists or not.

Args: user_google_email: User's Google email address document_id: ID of the document to update section_type: Type of section to create or update ("header" or "footer") content: Text content for the header/footer header_footer_type: Type of header/footer ("DEFAULT", "FIRST_PAGE_ONLY", "EVEN_PAGE")

Returns: str: Confirmation message with update details

Updates metadata, properties, and/or content of a Google Drive file.

Providing one of `content, file_path, or file_url` replaces the file's content in place. The source is uploaded with its source MIME type so the Drive API applies the same format conversion as import_to_google_doc (markdown headings, tables, bold, etc.) while preserving the existing file ID, sharing, comments, and links. Metadata and content can be updated in a single call.

Apply paragraph-level formatting, heading styles, and/or list formatting to a range in a Google Doc.

This tool can apply named heading styles (H1-H6) for semantic document structure, create bulleted or numbered lists with nested indentation, and customize paragraph properties like alignment, spacing, and indentation. All operations can be applied in a single call.

Update or create files in a script project.

By default this merges the supplied files into the existing project by file name, leaving other files untouched. Set merge=False to replace the entire project: any existing file omitted from files is permanently deleted.