google-tools-mcp 1.2.11 → 1.2.12

package/README.md

@@ -109,6 +109,24 @@ Add the credentials directly to your MCP configuration:
 
 ### Step 3: Add to Your MCP Client
 
+#### Local unpublished checkout
+
+To call a local tool directly without publishing or using MCP transport, use
+`local:tool`. This loads the unpublished checkout, registers the real tools in
+memory, validates the arguments, and calls the tool's `execute` function:
+
+```bash
+npm run local:tool -- list
+npm run local:tool -- help
+npm run local:tool -- readDocument documentId=... format=markdown
+```
+
+For larger arguments, put JSON in a file and pass it with `@`:
+
+```bash
+npm run local:tool -- replaceDocumentWithMarkdown @args.json
+```
+
 #### Codex
 
 ```bash

package/dist/markdown-transformer/docsToMarkdown.js

@@ -15,34 +15,43 @@ const CODE_FONT_FAMILIES = new Set(['Roboto Mono', 'Courier New', 'Consolas', 'm
  * underline, links, code), ordered & unordered lists with nesting, tables,
  * and section breaks.
  */
-export function docsJsonToMarkdown(docData) {
+export function docsJsonToMarkdown(docData, options = {}) {
     const body = docData.body;
     if (!body?.content) {
         return '';
     }
     const lists = docData.lists ?? {};
+    const conversionOptions = {
+        richMarkdown: options.plainMarkdown ? false : options.richMarkdown ?? true,
+    };
     let markdown = '';
     for (const element of body.content) {
         if (element.paragraph) {
-            markdown += convertParagraph(element.paragraph, lists);
+            markdown += convertParagraph(element.paragraph, lists, conversionOptions);
         }
         else if (element.table) {
-            markdown += convertTable(element.table);
+            markdown += convertTable(element.table, conversionOptions);
         }
         else if (element.sectionBreak) {
+            if (isInitialDocumentSectionBreak(element)) {
+                continue;
+            }
             markdown += '\n---\n\n';
         }
     }
     return markdown.trim();
 }
+function isInitialDocumentSectionBreak(element) {
+    return element.endIndex === 1 && element.startIndex === undefined;
+}
 // --- Paragraph Conversion ---
-function convertParagraph(paragraph, lists) {
+function convertParagraph(paragraph, lists, options) {
     // 1. Determine paragraph type
     const headingLevel = getHeadingLevel(paragraph);
     const listInfo = getListInfo(paragraph, lists);
     // 2. Extract text content with inline formatting
     const elements = paragraph.elements ?? [];
-    const text = extractFormattedText(elements);
+    const text = extractFormattedText(elements, options);
     // 3. Format based on type
     if (headingLevel && text.trim()) {
         const hashes = '#'.repeat(Math.min(headingLevel, 6));
@@ -54,7 +63,15 @@ function convertParagraph(paragraph, lists) {
         return `${indent}${marker} ${text.trim()}\n`;
     }
     if (text.trim()) {
-        return `${text.trim()}\n\n`;
+        const trimmed = text.trim();
+        if (options.richMarkdown && isBlockquoteParagraph(paragraph)) {
+            return `<blockquote>${trimmed}</blockquote>\n\n`;
+        }
+        const alignment = paragraphAlignmentToHtml(paragraph.paragraphStyle?.alignment);
+        if (options.richMarkdown && alignment) {
+            return `<p align="${alignment}">${trimmed}</p>\n\n`;
+        }
+        return `${trimmed}\n\n`;
     }
     return '\n';
 }
@@ -91,16 +108,16 @@ function getListInfo(paragraph, lists) {
     return { ordered, nestingLevel };
 }
 // --- Text Run Conversion ---
-function extractFormattedText(elements) {
+function extractFormattedText(elements, options) {
     let result = '';
     for (const element of elements) {
         if (element.textRun) {
-            result += convertTextRun(element.textRun);
+            result += convertTextRun(element.textRun, options);
         }
     }
     return result;
 }
-function convertTextRun(textRun) {
+function convertTextRun(textRun, options) {
     let text = textRun.content ?? '';
     const style = textRun.textStyle;
     if (!style)
@@ -134,20 +151,72 @@ function convertTextRun(textRun) {
     if (style.strikethrough) {
         formatted = `~~${formatted}~~`;
     }
-    if (style.underline && !style.link) {
+    if (options.richMarkdown && style.underline && !style.link) {
         formatted = `<u>${formatted}</u>`;
     }
+    if (options.richMarkdown) {
+        formatted = applyRichTextStyle(formatted, style);
+    }
     if (style.link?.url) {
         formatted = `[${formatted}](${style.link.url})`;
     }
     return formatted + (trailingNewline ? '\n' : '');
 }
+function applyRichTextStyle(text, style) {
+    const styles = [];
+    const fg = rgbColorToHex(style.foregroundColor?.color?.rgbColor);
+    const bg = rgbColorToHex(style.backgroundColor?.color?.rgbColor);
+    const fontSize = style.fontSize?.magnitude;
+    const fontFamily = style.weightedFontFamily?.fontFamily;
+    if (fg)
+        styles.push(`color:${fg}`);
+    if (bg)
+        styles.push(`background-color:${bg}`);
+    if (typeof fontSize === 'number')
+        styles.push(`font-size:${fontSize}pt`);
+    if (fontFamily && !CODE_FONT_FAMILIES.has(fontFamily))
+        styles.push(`font-family:${escapeHtmlAttr(fontFamily)}`);
+    if (styles.length === 0)
+        return text;
+    return `<span style="${styles.join(';')}">${text}</span>`;
+}
 function isCodeStyled(style) {
     const fontFamily = style.weightedFontFamily?.fontFamily;
     return typeof fontFamily === 'string' && CODE_FONT_FAMILIES.has(fontFamily);
 }
+function isBlockquoteParagraph(paragraph) {
+    const style = paragraph.paragraphStyle;
+    return Boolean(style?.borderLeft ||
+        style?.indentStart?.magnitude >= 30 ||
+        style?.indentFirstLine?.magnitude >= 30);
+}
+function paragraphAlignmentToHtml(alignment) {
+    switch (alignment) {
+        case 'CENTER':
+            return 'center';
+        case 'END':
+        case 'RIGHT':
+            return 'right';
+        case 'JUSTIFIED':
+            return 'justify';
+        default:
+            return null;
+    }
+}
+function rgbColorToHex(rgb) {
+    if (!rgb)
+        return null;
+    const toHex = (value) => {
+        const normalized = Math.max(0, Math.min(255, Math.round((value ?? 0) * 255)));
+        return normalized.toString(16).padStart(2, '0');
+    };
+    return `#${toHex(rgb.red)}${toHex(rgb.green)}${toHex(rgb.blue)}`;
+}
+function escapeHtmlAttr(value) {
+    return value.replace(/&/g, '&amp;').replace(/"/g, '&quot;');
+}
 // --- Table Conversion ---
-function convertTable(table) {
+function convertTable(table, options) {
     if (!table.tableRows || table.tableRows.length === 0) {
         return '';
     }
@@ -162,15 +231,15 @@ function convertTable(table) {
             continue;
         let rowText = '|';
         for (const cell of row.tableCells) {
-            const cellText = extractCellText(cell);
+            const cellText = extractCellText(cell, options);
             rowText += ` ${cellText} |`;
         }
         markdown += rowText + '\n';
         // Add header separator after the first row
         if (isFirstRow) {
             let separator = '|';
-            for (let i = 0; i < row.tableCells.length; i++) {
-                separator += ' --- |';
+            for (const cell of row.tableCells) {
+                separator += ` ${tableAlignmentMarker(cell)} |`;
             }
             markdown += separator + '\n';
             isFirstRow = false;
@@ -242,18 +311,22 @@ function convertCodeBlockTable(table) {
     }
     return '\n```\n' + codeText + '\n```\n\n';
 }
-function extractCellText(cell) {
+function tableAlignmentMarker(cell) {
+    const alignment = paragraphAlignmentToHtml(cell.content?.[0]?.paragraph?.paragraphStyle?.alignment);
+    if (alignment === 'center')
+        return ':---:';
+    if (alignment === 'right')
+        return '---:';
+    return '---';
+}
+function extractCellText(cell, options) {
     let text = '';
     if (!cell.content)
         return text;
     for (const element of cell.content) {
         if (element.paragraph?.elements) {
-            for (const pe of element.paragraph.elements) {
-                if (pe.textRun?.content) {
-                    text += pe.textRun.content.replace(/\n/g, ' ').trim();
-                }
-            }
+            text += extractFormattedText(element.paragraph.elements, options).replace(/\n/g, ' ');
         }
     }
-    return text;
+    return text.trim().replace(/\|/g, '\\|');
 }

package/dist/markdown-transformer/index.js

@@ -61,12 +61,12 @@ export async function extractMarkdown(docs, documentId, options) {
         return docsJsonToMarkdown({
             body: targetTab.documentTab.body,
             lists: targetTab.documentTab.lists,
-        });
+        }, options);
     }
     return docsJsonToMarkdown({
         body: res.data.body,
         lists: res.data.lists,
-    });
+    }, options);
 }
 // --- insertMarkdown ---
 /**

package/dist/markdown-transformer/markdownToDocs.js

@@ -4,7 +4,7 @@ import { MarkdownConversionError } from '../types.js';
 // --- Markdown-it Setup ---
 function createParser() {
     return new MarkdownIt({
-        html: false,
+        html: true,
         linkify: true,
         typographer: false,
         breaks: false,
@@ -23,6 +23,79 @@ function getHeadingLevel(token) {
     const match = token.tag.match(/h(\d)/);
     return match ? parseInt(match[1], 10) : null;
 }
+function getAttr(token, name) {
+    return token.attrs?.find((attr) => attr[0].toLowerCase() === name.toLowerCase())?.[1] ?? null;
+}
+function parseAlignmentFromStyle(style) {
+    const match = style?.match(/(?:^|;)\s*text-align\s*:\s*(left|center|right|justify)\s*(?:;|$)/i);
+    if (!match)
+        return null;
+    return alignmentToDocs(match[1]);
+}
+function alignmentToDocs(value) {
+    switch (value.toLowerCase()) {
+        case 'center':
+            return 'CENTER';
+        case 'right':
+            return 'END';
+        case 'justify':
+        case 'justified':
+            return 'JUSTIFIED';
+        case 'left':
+            return 'START';
+        default:
+            return null;
+    }
+}
+function parseStyleDeclarations(style) {
+    const formatting = {};
+    if (!style)
+        return formatting;
+    for (const declaration of style.split(';')) {
+        const [rawName, ...rawValueParts] = declaration.split(':');
+        if (!rawName || rawValueParts.length === 0)
+            continue;
+        const name = rawName.trim().toLowerCase();
+        const value = rawValueParts.join(':').trim();
+        if ((name === 'color' || name === 'foreground-color') && /^#[0-9a-f]{6}$/i.test(value)) {
+            formatting.foregroundColor = value;
+        }
+        else if ((name === 'background-color' || name === 'background') && /^#[0-9a-f]{6}$/i.test(value)) {
+            formatting.backgroundColor = value;
+        }
+        else if (name === 'font-size') {
+            const match = value.match(/^(\d+(?:\.\d+)?)pt$/i);
+            if (match)
+                formatting.fontSize = Number(match[1]);
+        }
+        else if (name === 'font-family') {
+            const family = value.split(',')[0]?.trim().replace(/^['"]|['"]$/g, '');
+            if (family && /^[\w .-]+$/.test(family))
+                formatting.fontFamily = family;
+        }
+    }
+    return formatting;
+}
+function parseRichHtmlTag(rawHtml) {
+    const trimmed = rawHtml.trim();
+    const match = trimmed.match(/^<\/?\s*([a-z0-9]+)([^>]*)\/?>$/i);
+    if (!match)
+        return null;
+    const tag = match[1].toLowerCase();
+    const attrs = match[2] ?? '';
+    const closing = /^<\s*\//.test(trimmed);
+    const selfClosing = /\/\s*>$/.test(trimmed);
+    return { tag, attrs, closing, selfClosing };
+}
+function parseAttrs(rawAttrs) {
+    const attrs = {};
+    const attrRegex = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+))/g;
+    let match;
+    while ((match = attrRegex.exec(rawAttrs)) !== null) {
+        attrs[match[1].toLowerCase()] = match[2] ?? match[3] ?? match[4] ?? '';
+    }
+    return attrs;
+}
 const CODE_FONT_FAMILY = 'Roboto Mono';
 const CODE_TEXT_HEX = '#188038';
 const CODE_BACKGROUND_HEX = '#F1F3F4';
@@ -86,6 +159,8 @@ export function convertMarkdownToRequests(markdown, startIndex = 1, tabId, optio
         codeBlockRanges: [],
         tableState: undefined,
         inTableCell: false,
+        paragraphFormattingStack: [],
+        htmlParagraphPushStack: [],
         tabId,
         titleConsumed: false,
         firstHeadingAsTitle: options?.firstHeadingAsTitle ?? false,
@@ -231,10 +306,12 @@ function processToken(token, context) {
         case 'th_open':
         case 'td_open': {
             if (context.tableState) {
+                const alignment = parseAlignmentFromStyle(getAttr(token, 'style'));
                 context.tableState.currentCell = {
                     text: '',
                     isHeader: context.tableState.inHeader || token.type === 'th_open',
                     textRanges: [],
+                    alignment,
                 };
                 context.inTableCell = true;
             }
@@ -264,9 +341,20 @@ function processToken(token, context) {
         case 'hr':
             handleHorizontalRule(context);
             break;
-        // Blockquotes (skip for now)
         case 'blockquote_open':
+            context.paragraphFormattingStack.push({
+                indentStart: 36,
+                borderLeft: true,
+            });
+            break;
         case 'blockquote_close':
+            context.paragraphFormattingStack.pop();
+            break;
+        case 'html_inline':
+            handleHtmlInlineToken(token, context);
+            break;
+        case 'html_block':
+            handleHtmlBlockToken(token, context);
             break;
         default:
             break;
@@ -306,6 +394,106 @@ function handleHorizontalRule(context) {
     insertText('\n', context);
     context.hrRanges.push({ startIndex: start, endIndex: context.currentIndex });
 }
+function handleHtmlInlineToken(token, context) {
+    const parsed = parseRichHtmlTag(token.content);
+    if (!parsed)
+        return;
+    const attrs = parseAttrs(parsed.attrs);
+    if (parsed.selfClosing && parsed.tag !== 'br')
+        return;
+    if (parsed.closing) {
+        switch (parsed.tag) {
+            case 'u':
+                popFormatting(context, 'underline');
+                break;
+            case 'mark':
+                popFormatting(context, 'backgroundColor');
+                break;
+            case 'span':
+                popFormatting(context, 'richSpan');
+                break;
+            case 'p':
+            case 'div': {
+                const pushed = context.htmlParagraphPushStack.pop();
+                if (pushed)
+                    context.paragraphFormattingStack.pop();
+                break;
+            }
+            case 'blockquote':
+                context.paragraphFormattingStack.pop();
+                break;
+        }
+        return;
+    }
+    switch (parsed.tag) {
+        case 'u':
+            context.formattingStack.push({ underline: true });
+            break;
+        case 'mark':
+            context.formattingStack.push({ backgroundColor: '#FFF2CC' });
+            break;
+        case 'span': {
+            const formatting = parseStyleDeclarations(attrs.style);
+            if (hasFormatting(formatting)) {
+                formatting.richSpan = true;
+                context.formattingStack.push(formatting);
+            }
+            break;
+        }
+        case 'p':
+        case 'div': {
+            const alignment = alignmentToDocs(attrs.align ?? '') ?? parseAlignmentFromStyle(attrs.style);
+            if (alignment) {
+                context.paragraphFormattingStack.push({ alignment });
+                context.htmlParagraphPushStack.push(true);
+            }
+            else {
+                context.htmlParagraphPushStack.push(false);
+            }
+            break;
+        }
+        case 'blockquote':
+            context.paragraphFormattingStack.push({
+                indentStart: 36,
+                borderLeft: true,
+            });
+            break;
+        case 'br':
+            insertText('\n', context);
+            break;
+    }
+}
+function handleHtmlBlockToken(token, context) {
+    const content = token.content.trim();
+    const match = content.match(/^<\s*(p|div|blockquote)\b([^>]*)>([\s\S]*)<\/\s*\1\s*>$/i);
+    if (!match)
+        return;
+    const tag = match[1].toLowerCase();
+    const attrs = parseAttrs(match[2]);
+    const inner = match[3];
+    let pushedParagraphFormatting = false;
+    if (tag === 'blockquote') {
+        context.paragraphFormattingStack.push({
+            indentStart: 36,
+            borderLeft: true,
+        });
+        pushedParagraphFormatting = true;
+    }
+    else {
+        const alignment = alignmentToDocs(attrs.align ?? '') ?? parseAlignmentFromStyle(attrs.style);
+        if (alignment) {
+            context.paragraphFormattingStack.push({ alignment });
+            pushedParagraphFormatting = true;
+        }
+    }
+    const parser = createParser();
+    for (const child of parser.parse(inner, {})) {
+        processToken(child, context);
+    }
+    if (pushedParagraphFormatting) {
+        context.paragraphFormattingStack.pop();
+    }
+}
 // --- Paragraph Handlers ---
 function handleParagraphOpen(context) {
     if (context.listStack.length === 0) {
@@ -329,10 +517,15 @@ function handleParagraphClose(context) {
     }
     // Record the range for normal paragraphs (not list items) so we can apply spacing later
     if (paragraphStart !== undefined && context.listStack.length === 0) {
-        context.normalParagraphRanges.push({
+        const paragraphRange = {
             startIndex: paragraphStart,
             endIndex: context.currentIndex,
-        });
+        };
+        const paragraphFormatting = mergeParagraphFormattingStack(context.paragraphFormattingStack);
+        if (hasParagraphFormatting(paragraphFormatting)) {
+            paragraphRange.formatting = paragraphFormatting;
+        }
+        context.normalParagraphRanges.push(paragraphRange);
     }
     context.currentParagraphStart = undefined;
 }
@@ -548,15 +741,13 @@ function handleTableClose(tableState, context) {
                 if (range.formatting.bold ||
                     range.formatting.italic ||
                     range.formatting.strikethrough ||
-                    range.formatting.code) {
-                    const styleReq = buildUpdateTextStyleRequest(absStart, absEnd, {
-                        bold: range.formatting.bold,
-                        italic: range.formatting.italic,
-                        strikethrough: range.formatting.strikethrough,
-                        fontFamily: range.formatting.code ? CODE_FONT_FAMILY : undefined,
-                        foregroundColor: range.formatting.code ? CODE_TEXT_HEX : undefined,
-                        backgroundColor: range.formatting.code ? CODE_BACKGROUND_HEX : undefined,
-                    }, context.tabId);
+                    range.formatting.code ||
+                    range.formatting.underline ||
+                    range.formatting.foregroundColor ||
+                    range.formatting.backgroundColor ||
+                    range.formatting.fontSize ||
+                    range.formatting.fontFamily) {
+                    const styleReq = buildUpdateTextStyleRequest(absStart, absEnd, formattingToTextStyle(range.formatting), context.tabId);
                     if (styleReq)
                         context.formatRequests.push(styleReq.request);
                 }
@@ -572,6 +763,11 @@ function handleTableClose(tableState, context) {
                 if (headerStyleReq)
                     context.formatRequests.push(headerStyleReq.request);
             }
+            if (cell.alignment) {
+                const alignmentReq = buildUpdateParagraphStyleRequest(adjustedIndex, adjustedIndex + cell.text.length, { alignment: cell.alignment }, context.tabId);
+                if (alignmentReq)
+                    context.formatRequests.push(alignmentReq.request);
+            }
             cumulativeTextLength += cell.text.length;
         }
     }
@@ -606,6 +802,18 @@ function mergeFormattingStack(stack) {
             merged.code = state.code;
         if (state.link !== undefined)
             merged.link = state.link;
+        if (state.underline !== undefined)
+            merged.underline = state.underline;
+        if (state.foregroundColor !== undefined)
+            merged.foregroundColor = state.foregroundColor;
+        if (state.backgroundColor !== undefined)
+            merged.backgroundColor = state.backgroundColor;
+        if (state.fontSize !== undefined)
+            merged.fontSize = state.fontSize;
+        if (state.fontFamily !== undefined)
+            merged.fontFamily = state.fontFamily;
+        if (state.richSpan !== undefined)
+            merged.richSpan = state.richSpan;
     }
     return merged;
 }
@@ -614,7 +822,41 @@ function hasFormatting(formatting) {
         formatting.italic === true ||
         formatting.strikethrough === true ||
         formatting.code === true ||
-        formatting.link !== undefined);
+        formatting.link !== undefined ||
+        formatting.underline === true ||
+        formatting.foregroundColor !== undefined ||
+        formatting.backgroundColor !== undefined ||
+        formatting.fontSize !== undefined ||
+        formatting.fontFamily !== undefined);
+}
+function formattingToTextStyle(formatting) {
+    return {
+        bold: formatting.bold,
+        italic: formatting.italic,
+        underline: formatting.underline,
+        strikethrough: formatting.strikethrough,
+        fontFamily: formatting.code ? CODE_FONT_FAMILY : formatting.fontFamily,
+        fontSize: formatting.fontSize,
+        foregroundColor: formatting.code ? CODE_TEXT_HEX : formatting.foregroundColor,
+        backgroundColor: formatting.code ? CODE_BACKGROUND_HEX : formatting.backgroundColor,
+    };
+}
+function mergeParagraphFormattingStack(stack) {
+    const merged = {};
+    for (const state of stack) {
+        if (state.alignment !== undefined)
+            merged.alignment = state.alignment;
+        if (state.indentStart !== undefined)
+            merged.indentStart = state.indentStart;
+        if (state.borderLeft !== undefined)
+            merged.borderLeft = state.borderLeft;
+    }
+    return merged;
+}
+function hasParagraphFormatting(formatting) {
+    return (formatting.alignment !== undefined ||
+        formatting.indentStart !== undefined ||
+        formatting.borderLeft === true);
 }
 function popFormatting(context, type) {
     for (let i = context.formattingStack.length - 1; i >= 0; i--) {
@@ -661,15 +903,13 @@ function finalizeFormatting(context) {
         if (range.formatting.bold ||
             range.formatting.italic ||
             range.formatting.strikethrough ||
-            range.formatting.code) {
-            const styleRequest = buildUpdateTextStyleRequest(range.startIndex, range.endIndex, {
-                bold: range.formatting.bold,
-                italic: range.formatting.italic,
-                strikethrough: range.formatting.strikethrough,
-                fontFamily: range.formatting.code ? CODE_FONT_FAMILY : undefined,
-                foregroundColor: range.formatting.code ? CODE_TEXT_HEX : undefined,
-                backgroundColor: range.formatting.code ? CODE_BACKGROUND_HEX : undefined,
-            }, context.tabId);
+            range.formatting.code ||
+            range.formatting.underline ||
+            range.formatting.foregroundColor ||
+            range.formatting.backgroundColor ||
+            range.formatting.fontSize ||
+            range.formatting.fontFamily) {
+            const styleRequest = buildUpdateTextStyleRequest(range.startIndex, range.endIndex, formattingToTextStyle(range.formatting), context.tabId);
             if (styleRequest) {
                 context.formatRequests.push(styleRequest.request);
             }
@@ -711,6 +951,38 @@ function finalizeFormatting(context) {
                 fields: 'spaceBelow',
             },
         });
+        if (normalRange.formatting) {
+            const paraStyle = {};
+            const fields = [];
+            if (normalRange.formatting.alignment) {
+                paraStyle.alignment = normalRange.formatting.alignment;
+                fields.push('alignment');
+            }
+            if (normalRange.formatting.indentStart !== undefined) {
+                paraStyle.indentStart = { magnitude: normalRange.formatting.indentStart, unit: 'PT' };
+                fields.push('indentStart');
+            }
+            if (normalRange.formatting.borderLeft) {
+                paraStyle.borderLeft = {
+                    color: {
+                        color: { rgbColor: { red: 0.75, green: 0.75, blue: 0.75 } },
+                    },
+                    width: { magnitude: 2, unit: 'PT' },
+                    padding: { magnitude: 6, unit: 'PT' },
+                    dashStyle: 'SOLID',
+                };
+                fields.push('borderLeft');
+            }
+            if (fields.length > 0) {
+                context.formatRequests.push({
+                    updateParagraphStyle: {
+                        range,
+                        paragraphStyle: paraStyle,
+                        fields: fields.join(','),
+                    },
+                });
+            }
+        }
     }
     // List trailing spacing: apply spaceBelow to the last paragraph of each
     // top-level list so there is a visible gap between the list and the content

package/dist/tools/drive/createDocument.js

@@ -15,7 +15,7 @@ export function register(server) {
             initialContent: z
                 .string()
                 .optional()
-                .describe('Initial content to add to the document. By default, markdown syntax is converted to formatted Google Docs content (headings, bold, italic, links, lists, etc.).'),
+                .describe('Initial content to add to the document. By default, markdown syntax is converted to formatted Google Docs content (headings, bold, italic, links, tables, lists, and rich markdown HTML extensions).'),
             contentFormat: z
                 .enum(['markdown', 'raw'])
                 .optional()

package/dist/tools/extras/readDriveFile.js

@@ -49,14 +49,19 @@ export function register(server) {
             fileId: z
                 .string()
                 .describe('The Google Drive file ID (the long string between /d/ and /edit in a Drive URL).'),
-            format: z
-                .enum(['text', 'json', 'markdown'])
-                .optional()
-                .default('markdown')
-                .describe("Output format for Google Docs: 'markdown' (default), 'text' (plain text), 'json' (raw structure). Ignored for non-Doc files."),
-            range: z
-                .string()
-                .optional()
+            format: z
+                .enum(['text', 'json', 'markdown'])
+                .optional()
+                .default('markdown')
+                .describe("Output format for Google Docs: 'markdown' (default, preserves rich text/paragraph formatting with a small HTML allowlist), 'text' (plain text), 'json' (raw structure). Ignored for non-Doc files."),
+            plainMarkdown: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe('For Google Docs markdown output only. If true, suppresses rich HTML-style formatting extensions and returns cleaner portable markdown.'),
+            range: z
+                .string()
+                .optional()
                 .describe("A1 notation range for Google Sheets (e.g., 'Sheet1!A1:C10'). Required for spreadsheets."),
         }),
         execute: async (args, { log }) => {
@@ -117,8 +122,8 @@ async function readGoogleDoc(args, fileMeta, log) {
     let content;
     if (args.format === 'json') {
         content = JSON.stringify(res.data, null, 2);
-    } else if (args.format === 'markdown') {
-        content = docsJsonToMarkdown(res.data);
+    } else if (args.format === 'markdown') {
+        content = docsJsonToMarkdown(res.data, { plainMarkdown: args.plainMarkdown });
     } else {
         // text
         let textContent = '';

package/dist/tools/utils/appendMarkdownToGoogleDoc.js

@@ -10,7 +10,7 @@ export function register(server) {
     server.addTool({
         name: 'appendMarkdown',
         description: 'Best for adding new formatted content to the end of a document. ' +
-            'Supports headings, bold, italic, strikethrough, links, and bullet/numbered lists. ' +
+            'Supports headings, bold, italic, strikethrough, links, tables, bullet/numbered lists, and rich markdown HTML extensions for underline, color, highlight, font, alignment, and blockquotes. ' +
             'Use this instead of appendText when you need formatting. ' +
             'To edit existing content, use modifyText (single-location) or replaceDocumentWithMarkdown (section/full rewrite).',
         parameters: DocumentIdParameter.extend({

package/dist/tools/utils/replaceDocumentWithMarkdown.js

@@ -10,7 +10,7 @@ export function register(server) {
     server.addTool({
         name: 'replaceDocumentWithMarkdown',
         description: "Best for rewriting entire sections or full documents. Replaces the entire document body with content parsed from markdown. " +
-            "Supports headings, bold, italic, strikethrough, links, and bullet/numbered lists. " +
+            "Supports headings, bold, italic, strikethrough, links, tables, bullet/numbered lists, and rich markdown HTML extensions for underline, color, highlight, font, alignment, and blockquotes. " +
             "Use readDocument with format='markdown' first to get the current content, edit it, then call this tool to apply changes. " +
             "For small single-location edits (one line or paragraph), use modifyText instead. " +
             "To add content without rewriting, use appendMarkdown.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "google-tools-mcp",
-  "version": "1.2.11",
+  "version": "1.2.12",
   "description": "The easiest MCP server for Google Workspace — Drive, Docs, Sheets, Gmail, Calendar, and Forms. 153 tools with one-click browser auth. Read Word docs, PDFs, and spreadsheets straight from Drive.",
   "type": "module",
   "bin": {
@@ -49,12 +49,13 @@
     "ai-tools"
   ],
   "scripts": {
+    "local:tool": "node scripts/call-local-tool.js",
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
     "test:ci": "node --experimental-vm-modules node_modules/jest/bin/jest.js --ci --coverage"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/karthikcsq/google-tools-mcp.git"
+    "url": "git+https://github.com/karthikcsq/google-tools-mcp.git"
   },
   "homepage": "https://github.com/karthikcsq/google-tools-mcp#readme",
   "bugs": {