@triffon/google-docs-mcp 1.11.3-triffon

package/dist/tools/docs/formatting/updateTableColumnWidth.js

@@ -0,0 +1,51 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDocsClient } from '../../../clients.js';
+import { DocumentIdParameter } from '../../../types.js';
+import { getTableById } from '../structureHelpers.js';
+import * as GDocsHelpers from '../../../googleDocsApiHelpers.js';
+import { TABLE_INDEX_BODY_FIELDS, buildDocumentGetFields } from '../tabFieldMasks.js';
+export function register(server) {
+    server.addTool({
+        name: 'updateTableColumnWidth',
+        description: 'Sets fixed widths for one or more columns in an existing Google Docs table.',
+        parameters: DocumentIdParameter.extend({
+            tableId: z.string().min(1).describe('The MCP table ID returned by listDocumentTables.'),
+            columnIndices: z
+                .array(z.number().int().min(0))
+                .min(1)
+                .describe('Zero-based column indices to update.'),
+            widthPt: z.number().min(1).describe('Fixed width in points.'),
+            tabId: z.string().optional().describe('Optional target tab ID.'),
+        }),
+        execute: async (args, { log }) => {
+            const docs = await getDocsClient();
+            log.info(`Updating table column widths in ${args.tableId} for doc ${args.documentId}${args.tabId ? ` (tab: ${args.tabId})` : ''}`);
+            try {
+                const res = await docs.documents.get({
+                    documentId: args.documentId,
+                    ...(args.tabId && { includeTabsContent: true }),
+                    fields: buildDocumentGetFields(TABLE_INDEX_BODY_FIELDS, args.tabId),
+                });
+                const table = getTableById(res.data, args.tableId, args.tabId);
+                if (!table)
+                    throw new UserError(`Table "${args.tableId}" not found in document.`);
+                if (table.startIndex == null) {
+                    throw new UserError(`Table "${args.tableId}" does not expose a valid table start index.`);
+                }
+                if (args.columnIndices.some((index) => index >= table.columnCount)) {
+                    throw new UserError(`One or more column indices exceed table ${args.tableId} column count ${table.columnCount}.`);
+                }
+                const request = GDocsHelpers.buildTableColumnWidthRequest(table.startIndex, args.columnIndices, args.widthPt, args.tabId);
+                await GDocsHelpers.executeBatchUpdate(docs, args.documentId, [request]);
+                return `Successfully updated width for ${args.columnIndices.length} column(s) in ${args.tableId}.`;
+            }
+            catch (error) {
+                log.error(`Error updating column widths for ${args.tableId} in doc ${args.documentId}: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to update table column width: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/docs/formatting/updateTableRowStyle.js

@@ -0,0 +1,74 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDocsClient } from '../../../clients.js';
+import { DocumentIdParameter } from '../../../types.js';
+import { getTableById } from '../structureHelpers.js';
+import * as GDocsHelpers from '../../../googleDocsApiHelpers.js';
+import { TABLE_INDEX_BODY_FIELDS, buildDocumentGetFields } from '../tabFieldMasks.js';
+export function register(server) {
+    server.addTool({
+        name: 'updateTableRowStyle',
+        description: 'Applies row-level styling to a Google Docs table, including minimum row height and optional pinned header rows.',
+        parameters: DocumentIdParameter.extend({
+            tableId: z.string().min(1).describe('The MCP table ID returned by listDocumentTables.'),
+            rowIndices: z
+                .array(z.number().int().min(0))
+                .min(1)
+                .describe('Zero-based row indices to style.'),
+            minRowHeightPt: z.number().min(0).optional().describe('Minimum row height in points.'),
+            preventOverflow: z
+                .boolean()
+                .optional()
+                .describe('Whether row content should avoid overflowing outside the row.'),
+            pinnedHeaderRowsCount: z
+                .number()
+                .int()
+                .min(0)
+                .optional()
+                .describe('Optional number of header rows to pin at the top of the table.'),
+            tabId: z.string().optional().describe('Optional target tab ID.'),
+        }).refine((data) => data.minRowHeightPt !== undefined ||
+            data.preventOverflow !== undefined ||
+            data.pinnedHeaderRowsCount !== undefined, {
+            message: 'At least one row style option must be provided.',
+        }),
+        execute: async (args, { log }) => {
+            const docs = await getDocsClient();
+            log.info(`Updating table row style in ${args.tableId} for doc ${args.documentId}${args.tabId ? ` (tab: ${args.tabId})` : ''}`);
+            try {
+                const res = await docs.documents.get({
+                    documentId: args.documentId,
+                    ...(args.tabId && { includeTabsContent: true }),
+                    fields: buildDocumentGetFields(TABLE_INDEX_BODY_FIELDS, args.tabId),
+                });
+                const table = getTableById(res.data, args.tableId, args.tabId);
+                if (!table)
+                    throw new UserError(`Table "${args.tableId}" not found in document.`);
+                if (table.startIndex == null) {
+                    throw new UserError(`Table "${args.tableId}" does not expose a valid table start index.`);
+                }
+                if (args.rowIndices.some((index) => index >= table.rowCount)) {
+                    throw new UserError(`One or more row indices exceed table ${args.tableId} row count ${table.rowCount}.`);
+                }
+                const requests = [];
+                const styleRequest = GDocsHelpers.buildTableRowStyleRequest(table.startIndex, args.rowIndices, args.minRowHeightPt, args.preventOverflow, args.tabId);
+                if (styleRequest)
+                    requests.push(styleRequest);
+                if (args.pinnedHeaderRowsCount !== undefined) {
+                    requests.push(GDocsHelpers.buildPinTableHeaderRowsRequest(table.startIndex, args.pinnedHeaderRowsCount, args.tabId));
+                }
+                if (requests.length === 0) {
+                    throw new UserError('No row style requests were generated.');
+                }
+                await GDocsHelpers.executeBatchUpdate(docs, args.documentId, requests);
+                return `Successfully updated row style for ${args.tableId}.`;
+            }
+            catch (error) {
+                log.error(`Error updating table row style for ${args.tableId} in doc ${args.documentId}: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to update table row style: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/docs/getTableStructure.js

@@ -0,0 +1,48 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDocsClient } from '../../clients.js';
+import { DocumentIdParameter } from '../../types.js';
+import { getTableById } from './structureHelpers.js';
+import { TABLE_CONTENT_INDEXED_BODY_FIELDS, buildDocumentGetFields } from './tabFieldMasks.js';
+export function register(server) {
+    server.addTool({
+        name: 'getTableStructure',
+        description: 'Returns detailed structure for a table in a Google Document, including row/column counts and extracted cell text.',
+        parameters: DocumentIdParameter.extend({
+            tableId: z
+                .string()
+                .min(1)
+                .describe('The MCP table ID returned by listDocumentTables, for example "table:body:0".'),
+            tabId: z
+                .string()
+                .optional()
+                .describe('The ID of the specific tab to inspect. If not specified, inspects the first tab or legacy document body.'),
+        }),
+        execute: async (args, { log }) => {
+            const docs = await getDocsClient();
+            log.info(`Getting table structure for ${args.tableId} in ${args.documentId}${args.tabId ? ` (tab: ${args.tabId})` : ''}`);
+            try {
+                const res = await docs.documents.get({
+                    documentId: args.documentId,
+                    ...(args.tabId && { includeTabsContent: true }),
+                    fields: buildDocumentGetFields(TABLE_CONTENT_INDEXED_BODY_FIELDS, args.tabId),
+                });
+                const table = getTableById(res.data, args.tableId, args.tabId);
+                if (!table) {
+                    throw new UserError(`Table "${args.tableId}" not found in document.`);
+                }
+                return JSON.stringify(table, null, 2);
+            }
+            catch (error) {
+                log.error(`Error getting table structure for ${args.tableId} in doc ${args.documentId}: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                if (error.code === 404)
+                    throw new UserError(`Document not found (ID: ${args.documentId}).`);
+                if (error.code === 403)
+                    throw new UserError(`Permission denied for document (ID: ${args.documentId}).`);
+                throw new UserError(`Failed to get table structure: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/docs/index.js

@@ -0,0 +1,66 @@
+// Core read/write
+import { register as readGoogleDoc } from './readGoogleDoc.js';
+import { register as listDocumentTabs } from './listDocumentTabs.js';
+import { register as renameTab } from './renameTab.js';
+import { register as addTab } from './addTab.js';
+import { register as appendToGoogleDoc } from './appendToGoogleDoc.js';
+import { register as insertText } from './insertText.js';
+import { register as deleteRange } from './deleteRange.js';
+import { register as modifyText } from './modifyText.js';
+import { register as findAndReplace } from './findAndReplace.js';
+import { register as findElement } from './findElement.js';
+// Structure
+import { register as insertTable } from './insertTable.js';
+import { register as insertTableWithData } from './insertTableWithData.js';
+import { register as insertPageBreak } from './insertPageBreak.js';
+import { register as insertSectionBreak } from './insertSectionBreak.js';
+import { register as updateSectionStyle } from './updateSectionStyle.js';
+import { register as insertImage } from './insertImage.js';
+import { register as insertDateChip } from './insertDateChip.js';
+import { register as insertPerson } from './insertPerson.js';
+import { register as insertRichLink } from './insertRichLink.js';
+import { register as listSmartChips } from './listSmartChips.js';
+import { register as cloneTable } from './cloneTable.js';
+import { register as listDocumentTables } from './listDocumentTables.js';
+import { register as getTableStructure } from './getTableStructure.js';
+import { register as findSectionsByHeading } from './findSectionsByHeading.js';
+import { register as replaceTableRowData } from './replaceTableRowData.js';
+import { register as appendTableRows } from './appendTableRows.js';
+import { register as deleteTableRows } from './deleteTableRows.js';
+// Sub-domains
+import { registerCommentTools } from './comments/index.js';
+import { registerFormattingTools } from './formatting/index.js';
+export function registerDocsTools(server) {
+    // Core read/write
+    readGoogleDoc(server);
+    listDocumentTabs(server);
+    renameTab(server);
+    addTab(server);
+    appendToGoogleDoc(server);
+    insertText(server);
+    deleteRange(server);
+    modifyText(server);
+    findAndReplace(server);
+    findElement(server);
+    // Structure
+    insertTable(server);
+    insertTableWithData(server);
+    insertPageBreak(server);
+    insertSectionBreak(server);
+    updateSectionStyle(server);
+    insertImage(server);
+    insertDateChip(server);
+    insertPerson(server);
+    insertRichLink(server);
+    listSmartChips(server);
+    cloneTable(server);
+    listDocumentTables(server);
+    getTableStructure(server);
+    findSectionsByHeading(server);
+    replaceTableRowData(server);
+    appendTableRows(server);
+    deleteTableRows(server);
+    // Sub-domains
+    registerFormattingTools(server);
+    registerCommentTools(server);
+}

package/dist/tools/docs/insertDateChip.js

@@ -0,0 +1,82 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDocsClient } from '../../clients.js';
+import { DocumentIdParameter } from '../../types.js';
+import * as GDocsHelpers from '../../googleDocsApiHelpers.js';
+const DateFormatSchema = z.enum([
+    'DATE_FORMAT_UNSPECIFIED',
+    'DATE_FORMAT_MONTH_DAY_ABBREVIATED',
+    'DATE_FORMAT_MONTH_DAY_FULL',
+    'DATE_FORMAT_MONTH_DAY_YEAR_ABBREVIATED',
+    'DATE_FORMAT_ISO8601',
+]);
+const TimeFormatSchema = z.enum([
+    'TIME_FORMAT_UNSPECIFIED',
+    'TIME_FORMAT_DISABLED',
+    'TIME_FORMAT_HOUR_MINUTE',
+    'TIME_FORMAT_HOUR_MINUTE_TIMEZONE',
+]);
+function toGoogleTimestamp(input) {
+    const date = new Date(input);
+    if (Number.isNaN(date.getTime())) {
+        throw new UserError(`Invalid date/time value: "${input}"`);
+    }
+    return date.toISOString();
+}
+export function register(server) {
+    server.addTool({
+        name: 'insertDateChip',
+        description: 'Inserts a Google Docs date smart chip at a specific paragraph location. This creates a real date element, not plain text.',
+        parameters: DocumentIdParameter.extend({
+            index: z
+                .number()
+                .int()
+                .min(1)
+                .describe('1-based character index within an existing paragraph where the date chip should be inserted.'),
+            date: z
+                .string()
+                .min(1)
+                .describe('Date or date-time input parseable by JavaScript Date, e.g. "2026-05-07T15:30:00+09:00".'),
+            timeZoneId: z
+                .string()
+                .optional()
+                .describe('Optional CLDR/IANA time zone, e.g. "Asia/Tokyo".'),
+            locale: z.string().optional().describe('Optional locale, e.g. "ja" or "en".'),
+            dateFormat: DateFormatSchema.optional().describe('How the date portion should be displayed.'),
+            timeFormat: TimeFormatSchema.optional().describe('How the time portion should be displayed.'),
+            tabId: z.string().optional().describe('Optional target tab ID.'),
+        }),
+        execute: async (args, { log }) => {
+            const docs = await getDocsClient();
+            log.info(`Inserting date chip into ${args.documentId} at index ${args.index}${args.tabId ? ` (tab: ${args.tabId})` : ''}`);
+            try {
+                if (args.tabId) {
+                    const targetTab = await GDocsHelpers.getDocumentTab(docs, args.documentId, args.tabId);
+                }
+                const location = { index: args.index };
+                if (args.tabId)
+                    location.tabId = args.tabId;
+                const request = {
+                    insertDate: {
+                        location: location,
+                        dateElementProperties: {
+                            timestamp: toGoogleTimestamp(args.date),
+                            timeZoneId: args.timeZoneId,
+                            locale: args.locale,
+                            dateFormat: args.dateFormat,
+                            timeFormat: args.timeFormat,
+                        },
+                    },
+                };
+                await GDocsHelpers.executeBatchUpdate(docs, args.documentId, [request]);
+                return `Successfully inserted a date chip at index ${args.index}${args.tabId ? ` in tab ${args.tabId}` : ''}.`;
+            }
+            catch (error) {
+                log.error(`Error inserting date chip into doc ${args.documentId}: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to insert date chip: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/docs/insertImage.js

@@ -0,0 +1,112 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDocsClient, getDriveClient, getScriptClient } from '../../clients.js';
+import { DocumentIdParameter } from '../../types.js';
+import * as GDocsHelpers from '../../googleDocsApiHelpers.js';
+export function register(server) {
+    server.addTool({
+        name: 'insertImage',
+        description: 'Inserts an inline image into a Google Document. Provide either a publicly accessible URL or a local file path. Local files are automatically uploaded to Google Drive before insertion.',
+        parameters: DocumentIdParameter.extend({
+            imageUrl: z
+                .string()
+                .url()
+                .optional()
+                .describe('Publicly accessible URL to the image (http:// or https://).'),
+            localImagePath: z
+                .string()
+                .optional()
+                .describe('Absolute path to a local image file (supports .jpg, .jpeg, .png, .gif, .bmp, .webp, .svg). The file will be uploaded to Google Drive.'),
+            index: z
+                .number()
+                .int()
+                .min(1)
+                .describe("1-based character index in the document body where the image should be inserted. Use readDocument with format='json' to inspect indices."),
+            width: z.number().min(1).optional().describe('Width of the image in points.'),
+            height: z.number().min(1).optional().describe('Height of the image in points.'),
+            tabId: z
+                .string()
+                .optional()
+                .describe('The ID of the specific tab to insert into. Use listDocumentTabs to get tab IDs. If not specified, inserts into the first tab.'),
+        })
+            .refine((data) => data.imageUrl || data.localImagePath, {
+            message: 'Either imageUrl or localImagePath must be provided.',
+        })
+            .refine((data) => !(data.imageUrl && data.localImagePath), {
+            message: 'Provide only one of imageUrl or localImagePath, not both.',
+        }),
+        execute: async (args, { log }) => {
+            const docs = await getDocsClient();
+            const appsScriptDeploymentId = process.env.APPS_SCRIPT_DEPLOYMENT_ID;
+            try {
+                if (args.tabId) {
+                    const targetTab = await GDocsHelpers.getDocumentTab(docs, args.documentId, args.tabId);
+                }
+                // --- Apps Script path: local files when APPS_SCRIPT_DEPLOYMENT_ID is set ---
+                if (args.localImagePath && appsScriptDeploymentId) {
+                    const drive = await getDriveClient();
+                    const scriptClient = await getScriptClient();
+                    log.info(`[AppsScript] Uploading ${args.localImagePath} to Drive (no public sharing)`);
+                    let parentFolderId;
+                    try {
+                        const docInfo = await drive.files.get({
+                            fileId: args.documentId,
+                            fields: 'parents',
+                            supportsAllDrives: true,
+                        });
+                        if (docInfo.data.parents && docInfo.data.parents.length > 0) {
+                            parentFolderId = docInfo.data.parents[0];
+                        }
+                    }
+                    catch (folderError) {
+                        log.warn(`Could not determine document's parent folder, using Drive root: ${folderError}`);
+                    }
+                    const driveFileId = await GDocsHelpers.uploadImageToDrive(drive, args.localImagePath, parentFolderId, true // skipPublicSharing
+                    );
+                    log.info(`[AppsScript] Inserting image via marker at index ${args.index} (fileId: ${driveFileId})`);
+                    await GDocsHelpers.insertImageViaAppsScript(docs, scriptClient, appsScriptDeploymentId, args.documentId, driveFileId, args.index, args.tabId);
+                    return `Successfully inserted local image at index ${args.index} via Apps Script${args.tabId ? ` in tab ${args.tabId}` : ''}.`;
+                }
+                // --- Standard path: public URL insertion via Docs API ---
+                let resolvedUrl;
+                if (args.localImagePath) {
+                    const drive = await getDriveClient();
+                    log.info(`Uploading local image ${args.localImagePath} and inserting at index ${args.index} in doc ${args.documentId}${args.tabId ? ` (tab: ${args.tabId})` : ''}`);
+                    let parentFolderId;
+                    try {
+                        const docInfo = await drive.files.get({
+                            fileId: args.documentId,
+                            fields: 'parents',
+                            supportsAllDrives: true,
+                        });
+                        if (docInfo.data.parents && docInfo.data.parents.length > 0) {
+                            parentFolderId = docInfo.data.parents[0];
+                        }
+                    }
+                    catch (folderError) {
+                        log.warn(`Could not determine document's parent folder, using Drive root: ${folderError}`);
+                    }
+                    resolvedUrl = await GDocsHelpers.uploadImageToDrive(drive, args.localImagePath, parentFolderId, false // explicit: needs public URL for Docs API insertion
+                    );
+                    log.info(`Image uploaded successfully, URL: ${resolvedUrl}`);
+                }
+                else {
+                    resolvedUrl = args.imageUrl;
+                    log.info(`Inserting image from URL ${resolvedUrl} at index ${args.index} in doc ${args.documentId}${args.tabId ? ` (tab: ${args.tabId})` : ''}`);
+                }
+                await GDocsHelpers.insertInlineImage(docs, args.documentId, resolvedUrl, args.index, args.width, args.height, args.tabId);
+                let sizeInfo = '';
+                if (args.width && args.height) {
+                    sizeInfo = ` with size ${args.width}x${args.height}pt`;
+                }
+                return `Successfully inserted image at index ${args.index}${sizeInfo}${args.tabId ? ` in tab ${args.tabId}` : ''}.`;
+            }
+            catch (error) {
+                log.error(`Error inserting image in doc ${args.documentId}: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to insert image: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/docs/insertPageBreak.js

@@ -0,0 +1,47 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDocsClient } from '../../clients.js';
+import { DocumentIdParameter } from '../../types.js';
+import * as GDocsHelpers from '../../googleDocsApiHelpers.js';
+export function register(server) {
+    server.addTool({
+        name: 'insertPageBreak',
+        description: 'Inserts a page break at a character index in the document.',
+        parameters: DocumentIdParameter.extend({
+            index: z
+                .number()
+                .int()
+                .min(1)
+                .describe("1-based character index within the document body. Use readDocument with format='json' to inspect indices."),
+            tabId: z
+                .string()
+                .optional()
+                .describe('The ID of the specific tab to insert into. Use listDocumentTabs to get tab IDs. If not specified, inserts into the first tab.'),
+        }),
+        execute: async (args, { log }) => {
+            const docs = await getDocsClient();
+            log.info(`Inserting page break in doc ${args.documentId} at index ${args.index}${args.tabId ? ` (tab: ${args.tabId})` : ''}`);
+            try {
+                // If tabId is specified, verify the tab exists
+                if (args.tabId) {
+                    const targetTab = await GDocsHelpers.getDocumentTab(docs, args.documentId, args.tabId);
+                }
+                const location = { index: args.index };
+                if (args.tabId) {
+                    location.tabId = args.tabId;
+                }
+                const request = {
+                    insertPageBreak: { location },
+                };
+                await GDocsHelpers.executeBatchUpdate(docs, args.documentId, [request]);
+                return `Successfully inserted page break at index ${args.index}${args.tabId ? ` in tab ${args.tabId}` : ''}.`;
+            }
+            catch (error) {
+                log.error(`Error inserting page break in doc ${args.documentId}: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to insert page break: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/docs/insertPerson.js

@@ -0,0 +1,53 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDocsClient } from '../../clients.js';
+import { DocumentIdParameter } from '../../types.js';
+import * as GDocsHelpers from '../../googleDocsApiHelpers.js';
+export function register(server) {
+    server.addTool({
+        name: 'insertPerson',
+        description: 'Inserts a Google Docs person smart chip at a specific paragraph location using an email address.',
+        parameters: DocumentIdParameter.extend({
+            index: z
+                .number()
+                .int()
+                .min(1)
+                .describe('1-based character index within an existing paragraph where the person chip should be inserted.'),
+            email: z.string().email().describe('Email address linked to the person smart chip.'),
+            name: z
+                .string()
+                .optional()
+                .describe('Optional display name hint when Google Docs resolves the person mention.'),
+            tabId: z.string().optional().describe('Optional target tab ID.'),
+        }),
+        execute: async (args, { log }) => {
+            const docs = await getDocsClient();
+            log.info(`Inserting person chip into ${args.documentId} at index ${args.index}${args.tabId ? ` (tab: ${args.tabId})` : ''}`);
+            try {
+                if (args.tabId) {
+                    const targetTab = await GDocsHelpers.getDocumentTab(docs, args.documentId, args.tabId);
+                }
+                const location = { index: args.index };
+                if (args.tabId)
+                    location.tabId = args.tabId;
+                const request = {
+                    insertPerson: {
+                        location: location,
+                        personProperties: {
+                            email: args.email,
+                            name: args.name,
+                        },
+                    },
+                };
+                await GDocsHelpers.executeBatchUpdate(docs, args.documentId, [request]);
+                return `Successfully inserted a person chip at index ${args.index}${args.tabId ? ` in tab ${args.tabId}` : ''}.`;
+            }
+            catch (error) {
+                log.error(`Error inserting person chip into doc ${args.documentId}: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to insert person chip: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/docs/insertRichLink.js

@@ -0,0 +1,58 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDocsClient } from '../../clients.js';
+import { DocumentIdParameter } from '../../types.js';
+import * as GDocsHelpers from '../../googleDocsApiHelpers.js';
+export function register(server) {
+    server.addTool({
+        name: 'insertRichLink',
+        description: 'Inserts a Google Docs rich link smart chip at a specific paragraph location. Use for Google resource links such as Drive files or Calendar events.',
+        parameters: DocumentIdParameter.extend({
+            index: z
+                .number()
+                .int()
+                .min(1)
+                .describe('1-based character index within an existing paragraph where the rich link should be inserted.'),
+            uri: z.string().url().describe('URI of the Google resource for the rich link smart chip.'),
+            mimeType: z
+                .string()
+                .optional()
+                .describe('Optional MIME type of the linked resource, if known.'),
+            title: z
+                .string()
+                .optional()
+                .describe('Optional title hint. Google Docs may still resolve and display the canonical resource title.'),
+            tabId: z.string().optional().describe('Optional target tab ID.'),
+        }),
+        execute: async (args, { log }) => {
+            const docs = await getDocsClient();
+            log.info(`Inserting rich link into ${args.documentId} at index ${args.index}${args.tabId ? ` (tab: ${args.tabId})` : ''}`);
+            try {
+                if (args.tabId) {
+                    const targetTab = await GDocsHelpers.getDocumentTab(docs, args.documentId, args.tabId);
+                }
+                const location = { index: args.index };
+                if (args.tabId)
+                    location.tabId = args.tabId;
+                const request = {
+                    insertRichLink: {
+                        location: location,
+                        richLinkProperties: {
+                            uri: args.uri,
+                            mimeType: args.mimeType,
+                            title: args.title,
+                        },
+                    },
+                };
+                await GDocsHelpers.executeBatchUpdate(docs, args.documentId, [request]);
+                return `Successfully inserted a rich link at index ${args.index}${args.tabId ? ` in tab ${args.tabId}` : ''}.`;
+            }
+            catch (error) {
+                log.error(`Error inserting rich link into doc ${args.documentId}: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to insert rich link: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/docs/insertSectionBreak.js

@@ -0,0 +1,60 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDocsClient } from '../../clients.js';
+import { DocumentIdParameter } from '../../types.js';
+import * as GDocsHelpers from '../../googleDocsApiHelpers.js';
+export function buildInsertSectionBreakRequest(params) {
+    const location = { index: params.index };
+    if (params.tabId) {
+        location.tabId = params.tabId;
+    }
+    return {
+        insertSectionBreak: {
+            location,
+            sectionType: params.sectionType,
+        },
+    };
+}
+export function register(server) {
+    server.addTool({
+        name: 'insertSectionBreak',
+        description: 'Inserts a section break at a character index in the document. A section break starts a new section whose style (page orientation, margins, columns, page numbering) can then be customized with updateSectionStyle. Use sectionType="NEXT_PAGE" when you want the new section to start on a fresh page (required for mixing portrait and landscape pages in a single document) and "CONTINUOUS" when the new section should begin inline without a page break.',
+        parameters: DocumentIdParameter.extend({
+            index: z
+                .number()
+                .int()
+                .min(1)
+                .describe("1-based character index within the document body where the section break will be inserted. Use readDocument with format='json' to inspect indices."),
+            sectionType: z
+                .enum(['NEXT_PAGE', 'CONTINUOUS'])
+                .default('NEXT_PAGE')
+                .describe('The type of section break. NEXT_PAGE starts the new section on the next page (required to change page orientation). CONTINUOUS starts the new section inline without a page break. Defaults to NEXT_PAGE.'),
+            tabId: z
+                .string()
+                .optional()
+                .describe('The ID of the specific tab to insert into. Use listDocumentTabs to get tab IDs. If not specified, inserts into the first tab.'),
+        }),
+        execute: async (args, { log }) => {
+            const docs = await getDocsClient();
+            log.info(`Inserting ${args.sectionType} section break in doc ${args.documentId} at index ${args.index}${args.tabId ? ` (tab: ${args.tabId})` : ''}`);
+            try {
+                if (args.tabId) {
+                    const targetTab = await GDocsHelpers.getDocumentTab(docs, args.documentId, args.tabId);
+                }
+                const request = buildInsertSectionBreakRequest({
+                    index: args.index,
+                    sectionType: args.sectionType,
+                    tabId: args.tabId,
+                });
+                await GDocsHelpers.executeBatchUpdate(docs, args.documentId, [request]);
+                return `Successfully inserted ${args.sectionType} section break at index ${args.index}${args.tabId ? ` in tab ${args.tabId}` : ''}.`;
+            }
+            catch (error) {
+                log.error(`Error inserting section break in doc ${args.documentId}: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to insert section break: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}