google-tools-mcp 1.1.2 → 1.1.3

package/README.md

@@ -1,23 +1,26 @@
 # google-tools-mcp
 
-A unified MCP server for Google Workspace — Drive, Docs, Sheets, Gmail, Calendar, and Forms — with **153 tools** across 9 categories.
+The **easiest way** to connect your AI agent to Google Workspace.
 
-All tools are loaded at startup so they're immediately available to your AI agent. No discovery step needed.
+**153 tools** for Drive, Docs, Sheets, Gmail, Calendar, and Forms — all in one package. One install, one auth, and you're done.
 
-## Why This Exists
+```bash
+claude mcp add -s user google -- npx -y google-tools-mcp
+```
 
-Most Google MCP servers split functionality across separate packages. This server combines everything into one — single auth token, single process, single config.
+## Why google-tools-mcp?
 
-## Features
+- **One command to install.** No cloning repos, no building from source, no Docker. Just `npx -y google-tools-mcp` and it works.
+- **One login for everything.** A single OAuth flow gives you Drive, Docs, Sheets, Gmail, Calendar, and Forms. No juggling multiple tokens or servers.
+- **Auth that stays out of your way.** No browser popup until your first tool call. After that, your token is saved and you won't be asked again.
+- **Read anything in your Drive.** PDFs, Word docs (.docx), spreadsheets — your AI agent can read them directly. No extra setup.
+- **153 tools, zero config.** Every tool is available the moment the server starts. Send emails, create docs, manage calendar events, build forms — it's all there.
+- **Switch between Google accounts.** Set a profile name and keep work and personal accounts completely separate.
+- **No telemetry. No tracking. Fully open source.**
 
-- **153 tools** across 9 categories, all available immediately
-- **Single auth token** — one OAuth flow covers Drive, Docs, Sheets, Gmail, Calendar, and Forms
-- **Lazy-loading auth** — no browser popup until your first tool call
-- **No lazy tool loading** — all 153 tools are registered eagerly at startup since most MCP clients (including Claude Code) don't support `notifications/tools/list_changed`
-- **Multi-profile support** — separate tokens per Google account
-- **No telemetry**
+## Quick Start
 
-## Getting Started
+You can be up and running in under 5 minutes.
 
 ### Step 1: Create Google OAuth Credentials
 

package/dist/auth.js

@@ -52,6 +52,8 @@ const SCOPES = [
     'https://www.googleapis.com/auth/forms.body',
     'https://www.googleapis.com/auth/forms.body.readonly',
     'https://www.googleapis.com/auth/forms.responses.readonly',
+    // Slides
+    'https://www.googleapis.com/auth/presentations',
 ];
 
 // ---------------------------------------------------------------------------

package/dist/clients.js

@@ -13,6 +13,7 @@ let googleScript = null;
 let gmailClient = null;
 let calendarClient = null;
 let formsClient = null;
+let slidesClient = null;
 
 async function ensureAuth() {
     if (authClient) return;
@@ -44,6 +45,7 @@ async function reauthorize() {
     gmailClient = null;
     calendarClient = null;
     formsClient = null;
+    slidesClient = null;
     authClient = await authorize();
     logger.info('Re-authorization successful.');
 }
@@ -94,6 +96,14 @@ export async function initializeFormsClient() {
     return { authClient, formsClient };
 }
 
+// --- Slides client ---
+export async function initializeSlidesClient() {
+    if (slidesClient) return { authClient, slidesClient };
+    await ensureAuth();
+    if (!slidesClient) slidesClient = google.slides({ version: 'v1', auth: authClient });
+    return { authClient, slidesClient };
+}
+
 // --- Get auth client without triggering init (for diagnostics) ---
 export function getAuthClientIfReady() {
     return authClient;
@@ -109,6 +119,7 @@ export function resetClients() {
     gmailClient = null;
     calendarClient = null;
     formsClient = null;
+    slidesClient = null;
 }
 
 /**
@@ -177,3 +188,9 @@ export async function getFormsClient() {
     if (!forms) throw new UserError('Google Forms client is not initialized.');
     return forms;
 }
+
+export async function getSlidesClient() {
+    const { slidesClient: slides } = await initializeSlidesClient();
+    if (!slides) throw new UserError('Google Slides client is not initialized.');
+    return slides;
+}

package/dist/tools/index.js

@@ -172,6 +172,12 @@ const CATEGORIES = {
             registerFormsTools(server);
         },
     },
+    slides: {
+        async loader(server) {
+            const { registerSlidesTools } = await import('./slides/index.js');
+            registerSlidesTools(server);
+        },
+    },
 };
 
 // ---------------------------------------------------------------------------

package/dist/tools/slides/createPresentation.js

@@ -0,0 +1,104 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient, getDriveClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'createPresentation',
+        description:
+            'Create a new Google Slides presentation with initial slides. Each slide has a title and content body using the TITLE_AND_BODY layout.',
+        parameters: z.object({
+            name: z.string().describe('Presentation name'),
+            slides: z
+                .array(
+                    z.object({
+                        title: z.string().describe('Slide title'),
+                        content: z.string().describe('Slide body content'),
+                    }),
+                )
+                .min(1)
+                .describe('Array of slide objects with title and content'),
+            parentFolderId: z.string().optional().describe('Parent Drive folder ID (defaults to root)'),
+        }),
+        execute: async (args, { log }) => {
+            const slides = await getSlidesClient();
+            const drive = await getDriveClient();
+            log.info(`Creating presentation: ${args.name}`);
+
+            try {
+                // Create the presentation
+                const presentation = await slides.presentations.create({
+                    requestBody: { title: args.name },
+                });
+                const presentationId = presentation.data.presentationId;
+
+                // Move to folder if specified
+                if (args.parentFolderId) {
+                    await drive.files.update({
+                        fileId: presentationId,
+                        addParents: args.parentFolderId,
+                        removeParents: 'root',
+                        supportsAllDrives: true,
+                    });
+                }
+
+                // Create each slide and populate content
+                for (const slide of args.slides) {
+                    const slideObjectId = `slide_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+                    await slides.presentations.batchUpdate({
+                        presentationId,
+                        requestBody: {
+                            requests: [
+                                {
+                                    createSlide: {
+                                        objectId: slideObjectId,
+                                        slideLayoutReference: { predefinedLayout: 'TITLE_AND_BODY' },
+                                    },
+                                },
+                            ],
+                        },
+                    });
+
+                    // Get the slide to find placeholder IDs
+                    const slidePage = await slides.presentations.pages.get({
+                        presentationId,
+                        pageObjectId: slideObjectId,
+                    });
+
+                    let titleId = '';
+                    let bodyId = '';
+                    for (const el of slidePage.data.pageElements || []) {
+                        if (el.shape?.placeholder?.type === 'TITLE') titleId = el.objectId;
+                        else if (el.shape?.placeholder?.type === 'BODY') bodyId = el.objectId;
+                    }
+
+                    const insertRequests = [];
+                    if (titleId) insertRequests.push({ insertText: { objectId: titleId, text: slide.title, insertionIndex: 0 } });
+                    if (bodyId) insertRequests.push({ insertText: { objectId: bodyId, text: slide.content, insertionIndex: 0 } });
+
+                    if (insertRequests.length > 0) {
+                        await slides.presentations.batchUpdate({
+                            presentationId,
+                            requestBody: { requests: insertRequests },
+                        });
+                    }
+                }
+
+                return JSON.stringify(
+                    {
+                        presentationId,
+                        title: args.name,
+                        link: `https://docs.google.com/presentation/d/${presentationId}`,
+                        slidesCreated: args.slides.length,
+                    },
+                    null,
+                    2,
+                );
+            } catch (error) {
+                log.error(`Error creating presentation: ${error.message || error}`);
+                if (error.code === 401) throw new UserError('Authentication failed. Try logging out and re-authenticating.');
+                throw new UserError(`Failed to create presentation: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/createShape.js

@@ -0,0 +1,92 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'createSlidesShape',
+        description:
+            'Create a shape on a slide in Google Slides. Position and size are in EMU (914400 EMU = 1 inch).',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            pageObjectId: z.string().describe('Slide page object ID'),
+            shapeType: z
+                .enum(['RECTANGLE', 'ELLIPSE', 'DIAMOND', 'TRIANGLE', 'STAR', 'ROUND_RECTANGLE', 'ARROW'])
+                .describe('Shape type'),
+            x: z.number().describe('X position in EMU'),
+            y: z.number().describe('Y position in EMU'),
+            width: z.number().describe('Width in EMU'),
+            height: z.number().describe('Height in EMU'),
+            backgroundColor: z
+                .object({
+                    red: z.number().min(0).max(1).optional(),
+                    green: z.number().min(0).max(1).optional(),
+                    blue: z.number().min(0).max(1).optional(),
+                    alpha: z.number().min(0).max(1).optional(),
+                })
+                .optional()
+                .describe('Fill color (RGBA 0-1)'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+            const elementId = `shape_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+
+            const requests = [
+                {
+                    createShape: {
+                        objectId: elementId,
+                        shapeType: args.shapeType,
+                        elementProperties: {
+                            pageObjectId: args.pageObjectId,
+                            size: {
+                                width: { magnitude: args.width, unit: 'EMU' },
+                                height: { magnitude: args.height, unit: 'EMU' },
+                            },
+                            transform: {
+                                scaleX: 1,
+                                scaleY: 1,
+                                translateX: args.x,
+                                translateY: args.y,
+                                unit: 'EMU',
+                            },
+                        },
+                    },
+                },
+            ];
+
+            if (args.backgroundColor) {
+                requests.push({
+                    updateShapeProperties: {
+                        objectId: elementId,
+                        shapeProperties: {
+                            shapeBackgroundFill: {
+                                solidFill: {
+                                    color: {
+                                        rgbColor: {
+                                            red: args.backgroundColor.red || 0,
+                                            green: args.backgroundColor.green || 0,
+                                            blue: args.backgroundColor.blue || 0,
+                                        },
+                                    },
+                                    alpha: args.backgroundColor.alpha ?? 1,
+                                },
+                            },
+                        },
+                        fields: 'shapeBackgroundFill',
+                    },
+                });
+            }
+
+            try {
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: { requests },
+                });
+                return JSON.stringify({ success: true, objectId: elementId, message: `Created ${args.shapeType} shape: ${elementId}` });
+            } catch (error) {
+                log.error(`Error creating shape: ${error.message || error}`);
+                throw new UserError(`Failed to create shape: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/createTextBox.js

@@ -0,0 +1,82 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'createSlidesTextBox',
+        description:
+            'Create a text box on a slide in Google Slides. Position and size are in EMU (English Metric Units: 914400 EMU = 1 inch).',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            pageObjectId: z.string().describe('Slide page object ID'),
+            text: z.string().describe('Text content'),
+            x: z.number().describe('X position in EMU'),
+            y: z.number().describe('Y position in EMU'),
+            width: z.number().describe('Width in EMU'),
+            height: z.number().describe('Height in EMU'),
+            fontSize: z.number().optional().describe('Font size in points'),
+            bold: z.boolean().optional().describe('Make text bold'),
+            italic: z.boolean().optional().describe('Make text italic'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+            const elementId = `textBox_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+
+            const requests = [
+                {
+                    createShape: {
+                        objectId: elementId,
+                        shapeType: 'TEXT_BOX',
+                        elementProperties: {
+                            pageObjectId: args.pageObjectId,
+                            size: {
+                                width: { magnitude: args.width, unit: 'EMU' },
+                                height: { magnitude: args.height, unit: 'EMU' },
+                            },
+                            transform: {
+                                scaleX: 1,
+                                scaleY: 1,
+                                translateX: args.x,
+                                translateY: args.y,
+                                unit: 'EMU',
+                            },
+                        },
+                    },
+                },
+                {
+                    insertText: { objectId: elementId, text: args.text, insertionIndex: 0 },
+                },
+            ];
+
+            // Optional formatting
+            const textStyle = {};
+            const fields = [];
+            if (args.fontSize) { textStyle.fontSize = { magnitude: args.fontSize, unit: 'PT' }; fields.push('fontSize'); }
+            if (args.bold !== undefined) { textStyle.bold = args.bold; fields.push('bold'); }
+            if (args.italic !== undefined) { textStyle.italic = args.italic; fields.push('italic'); }
+
+            if (fields.length > 0) {
+                requests.push({
+                    updateTextStyle: {
+                        objectId: elementId,
+                        style: textStyle,
+                        fields: fields.join(','),
+                        textRange: { type: 'ALL' },
+                    },
+                });
+            }
+
+            try {
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: { requests },
+                });
+                return JSON.stringify({ success: true, objectId: elementId, message: `Created text box: ${elementId}` });
+            } catch (error) {
+                log.error(`Error creating text box: ${error.message || error}`);
+                throw new UserError(`Failed to create text box: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/deleteSlide.js

@@ -0,0 +1,30 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'deleteSlide',
+        description: 'Delete a slide from a Google Slides presentation.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            slideObjectId: z.string().describe('Object ID of the slide to delete'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+
+            try {
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: {
+                        requests: [{ deleteObject: { objectId: args.slideObjectId } }],
+                    },
+                });
+                return JSON.stringify({ success: true, message: `Deleted slide ${args.slideObjectId}` });
+            } catch (error) {
+                log.error(`Error deleting slide: ${error.message || error}`);
+                throw new UserError(`Failed to delete slide: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/duplicateSlide.js

@@ -0,0 +1,37 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'duplicateSlide',
+        description: 'Duplicate a slide in a Google Slides presentation.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            slideObjectId: z.string().describe('Object ID of the slide to duplicate'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+
+            try {
+                const response = await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: {
+                        requests: [{ duplicateObject: { objectId: args.slideObjectId } }],
+                    },
+                });
+
+                const newId = response.data.replies?.[0]?.duplicateObject?.objectId;
+                return JSON.stringify({
+                    success: true,
+                    originalId: args.slideObjectId,
+                    duplicateId: newId || null,
+                    message: `Duplicated slide ${args.slideObjectId}${newId ? ` -> ${newId}` : ''}`,
+                });
+            } catch (error) {
+                log.error(`Error duplicating slide: ${error.message || error}`);
+                throw new UserError(`Failed to duplicate slide: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/exportThumbnail.js

@@ -0,0 +1,42 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'exportSlideThumbnail',
+        description: 'Export a slide as a thumbnail image URL (PNG or JPEG) from a Google Slides presentation.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            slideObjectId: z.string().describe('Slide object ID'),
+            mimeType: z.enum(['PNG', 'JPEG']).optional().default('PNG').describe('Image format'),
+            size: z.enum(['SMALL', 'MEDIUM', 'LARGE']).optional().default('LARGE').describe('Thumbnail size'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+
+            try {
+                const response = await slidesApi.presentations.pages.getThumbnail({
+                    presentationId: args.presentationId,
+                    pageObjectId: args.slideObjectId,
+                    'thumbnailProperties.mimeType': args.mimeType,
+                    'thumbnailProperties.thumbnailSize': args.size,
+                });
+
+                const url = response.data?.contentUrl;
+                if (!url) throw new UserError('No thumbnail URL returned by Google Slides API.');
+
+                return JSON.stringify({
+                    slideObjectId: args.slideObjectId,
+                    mimeType: args.mimeType,
+                    size: args.size,
+                    thumbnailUrl: url,
+                });
+            } catch (error) {
+                if (error instanceof UserError) throw error;
+                log.error(`Error exporting thumbnail: ${error.message || error}`);
+                throw new UserError(`Failed to export thumbnail: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/formatParagraph.js

@@ -0,0 +1,72 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'formatSlidesParagraph',
+        description:
+            'Apply paragraph formatting (alignment, line spacing, bullets) to a text element in Google Slides.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            objectId: z.string().describe('Object ID of the text element'),
+            alignment: z.enum(['START', 'CENTER', 'END', 'JUSTIFIED']).optional().describe('Text alignment'),
+            lineSpacing: z.number().optional().describe('Line spacing multiplier (e.g. 1.5)'),
+            bulletStyle: z
+                .enum(['NONE', 'DISC', 'ARROW', 'SQUARE', 'DIAMOND', 'STAR', 'NUMBERED'])
+                .optional()
+                .describe('Bullet style'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+            const requests = [];
+
+            if (args.alignment) {
+                requests.push({
+                    updateParagraphStyle: {
+                        objectId: args.objectId,
+                        style: { alignment: args.alignment },
+                        fields: 'alignment',
+                    },
+                });
+            }
+
+            if (args.lineSpacing !== undefined) {
+                requests.push({
+                    updateParagraphStyle: {
+                        objectId: args.objectId,
+                        style: { lineSpacing: args.lineSpacing },
+                        fields: 'lineSpacing',
+                    },
+                });
+            }
+
+            if (args.bulletStyle) {
+                if (args.bulletStyle === 'NONE') {
+                    requests.push({ deleteParagraphBullets: { objectId: args.objectId } });
+                } else if (args.bulletStyle === 'NUMBERED') {
+                    requests.push({
+                        createParagraphBullets: { objectId: args.objectId, bulletPreset: 'NUMBERED_DIGIT_ALPHA_ROMAN' },
+                    });
+                } else {
+                    requests.push({
+                        createParagraphBullets: { objectId: args.objectId, bulletPreset: `BULLET_${args.bulletStyle}_CIRCLE_SQUARE` },
+                    });
+                }
+            }
+
+            if (requests.length === 0) throw new UserError('No formatting options specified');
+
+            try {
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: { requests },
+                });
+                return JSON.stringify({ success: true, message: `Applied paragraph formatting to ${args.objectId}` });
+            } catch (error) {
+                log.error(`Error formatting paragraph: ${error.message || error}`);
+                throw new UserError(`Failed to format paragraph: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/formatText.js

@@ -0,0 +1,84 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'formatSlidesText',
+        description:
+            'Apply text formatting (bold, italic, underline, font size, color, etc.) to a text element in Google Slides. Use getPresentation to find element objectIds first.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            objectId: z.string().describe('Object ID of the text element'),
+            startIndex: z.number().min(0).optional().describe('Start character index (0-based). Omit with endIndex to format all text.'),
+            endIndex: z.number().min(0).optional().describe('End character index (0-based)'),
+            bold: z.boolean().optional().describe('Make text bold'),
+            italic: z.boolean().optional().describe('Make text italic'),
+            underline: z.boolean().optional().describe('Underline text'),
+            strikethrough: z.boolean().optional().describe('Strikethrough text'),
+            fontSize: z.number().optional().describe('Font size in points'),
+            fontFamily: z.string().optional().describe('Font family name (e.g. "Arial", "Roboto")'),
+            foregroundColor: z
+                .object({
+                    red: z.number().min(0).max(1).optional(),
+                    green: z.number().min(0).max(1).optional(),
+                    blue: z.number().min(0).max(1).optional(),
+                })
+                .optional()
+                .describe('Text color as RGB values (0-1)'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+
+            const textStyle = {};
+            const fields = [];
+
+            if (args.bold !== undefined) { textStyle.bold = args.bold; fields.push('bold'); }
+            if (args.italic !== undefined) { textStyle.italic = args.italic; fields.push('italic'); }
+            if (args.underline !== undefined) { textStyle.underline = args.underline; fields.push('underline'); }
+            if (args.strikethrough !== undefined) { textStyle.strikethrough = args.strikethrough; fields.push('strikethrough'); }
+            if (args.fontSize !== undefined) {
+                textStyle.fontSize = { magnitude: args.fontSize, unit: 'PT' };
+                fields.push('fontSize');
+            }
+            if (args.fontFamily !== undefined) { textStyle.fontFamily = args.fontFamily; fields.push('fontFamily'); }
+            if (args.foregroundColor) {
+                textStyle.foregroundColor = {
+                    opaqueColor: {
+                        rgbColor: {
+                            red: args.foregroundColor.red || 0,
+                            green: args.foregroundColor.green || 0,
+                            blue: args.foregroundColor.blue || 0,
+                        },
+                    },
+                };
+                fields.push('foregroundColor');
+            }
+
+            if (fields.length === 0) throw new UserError('No formatting options specified');
+
+            const request = {
+                updateTextStyle: {
+                    objectId: args.objectId,
+                    style: textStyle,
+                    fields: fields.join(','),
+                    textRange:
+                        args.startIndex !== undefined && args.endIndex !== undefined
+                            ? { type: 'FIXED_RANGE', startIndex: args.startIndex, endIndex: args.endIndex }
+                            : { type: 'ALL' },
+                },
+            };
+
+            try {
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: { requests: [request] },
+                });
+                return JSON.stringify({ success: true, message: `Applied text formatting to ${args.objectId}` });
+            } catch (error) {
+                log.error(`Error formatting text: ${error.message || error}`);
+                throw new UserError(`Failed to format text: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/getPresentation.js

@@ -0,0 +1,87 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'getPresentation',
+        description:
+            'Get the content of a Google Slides presentation with element IDs for formatting. Optionally retrieve a single slide by index.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            slideIndex: z.number().min(0).optional().describe('Specific slide index (0-based). Omit to get all slides.'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+            log.info(`Reading presentation: ${args.presentationId}`);
+
+            try {
+                const presentation = await slidesApi.presentations.get({
+                    presentationId: args.presentationId,
+                });
+
+                if (!presentation.data.slides) {
+                    throw new UserError('No slides found in presentation');
+                }
+
+                const allSlides = presentation.data.slides;
+                const slides =
+                    args.slideIndex !== undefined ? [allSlides[args.slideIndex]] : allSlides;
+
+                const result = {
+                    title: presentation.data.title,
+                    presentationId: args.presentationId,
+                    totalSlides: allSlides.length,
+                    slides: slides.map((slide, idx) => {
+                        if (!slide?.objectId) return null;
+                        const slideInfo = {
+                            index: args.slideIndex ?? idx,
+                            objectId: slide.objectId,
+                            elements: [],
+                        };
+
+                        for (const el of slide.pageElements || []) {
+                            if (!el.objectId) continue;
+                            if (el.shape?.text) {
+                                let text = '';
+                                for (const te of el.shape.text.textElements || []) {
+                                    if (te.textRun?.content) text += te.textRun.content;
+                                }
+                                slideInfo.elements.push({
+                                    type: 'text',
+                                    objectId: el.objectId,
+                                    placeholderType: el.shape.placeholder?.type || null,
+                                    text: text.trim(),
+                                });
+                            } else if (el.shape) {
+                                slideInfo.elements.push({
+                                    type: 'shape',
+                                    objectId: el.objectId,
+                                    shapeType: el.shape.shapeType || 'Unknown',
+                                });
+                            } else if (el.image) {
+                                slideInfo.elements.push({ type: 'image', objectId: el.objectId });
+                            } else if (el.video) {
+                                slideInfo.elements.push({ type: 'video', objectId: el.objectId });
+                            } else if (el.table) {
+                                slideInfo.elements.push({
+                                    type: 'table',
+                                    objectId: el.objectId,
+                                    rows: el.table.rows,
+                                    columns: el.table.columns,
+                                });
+                            }
+                        }
+                        return slideInfo;
+                    }).filter(Boolean),
+                };
+
+                return JSON.stringify(result, null, 2);
+            } catch (error) {
+                if (error instanceof UserError) throw error;
+                log.error(`Error reading presentation: ${error.message || error}`);
+                throw new UserError(`Failed to read presentation: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/index.js

@@ -0,0 +1,33 @@
+import { register as createPresentation } from './createPresentation.js';
+import { register as updatePresentation } from './updatePresentation.js';
+import { register as getPresentation } from './getPresentation.js';
+import { register as formatText } from './formatText.js';
+import { register as formatParagraph } from './formatParagraph.js';
+import { register as styleShape } from './styleShape.js';
+import { register as setBackground } from './setBackground.js';
+import { register as createTextBox } from './createTextBox.js';
+import { register as createShape } from './createShape.js';
+import { register as speakerNotes } from './speakerNotes.js';
+import { register as deleteSlide } from './deleteSlide.js';
+import { register as duplicateSlide } from './duplicateSlide.js';
+import { register as reorderSlides } from './reorderSlides.js';
+import { register as replaceAllText } from './replaceAllText.js';
+import { register as exportThumbnail } from './exportThumbnail.js';
+
+export function registerSlidesTools(server) {
+    createPresentation(server);
+    updatePresentation(server);
+    getPresentation(server);
+    formatText(server);
+    formatParagraph(server);
+    styleShape(server);
+    setBackground(server);
+    createTextBox(server);
+    createShape(server);
+    speakerNotes(server);
+    deleteSlide(server);
+    duplicateSlide(server);
+    reorderSlides(server);
+    replaceAllText(server);
+    exportThumbnail(server);
+}

package/dist/tools/slides/reorderSlides.js

@@ -0,0 +1,41 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'reorderSlides',
+        description: 'Reorder one or more slides in a Google Slides presentation by moving them to a target index.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            slideObjectIds: z.array(z.string()).min(1).describe('Array of slide object IDs to move'),
+            insertionIndex: z.number().int().min(0).describe('Target insertion index (0-based)'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+
+            try {
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: {
+                        requests: [
+                            {
+                                updateSlidesPosition: {
+                                    slideObjectIds: args.slideObjectIds,
+                                    insertionIndex: args.insertionIndex,
+                                },
+                            },
+                        ],
+                    },
+                });
+                return JSON.stringify({
+                    success: true,
+                    message: `Reordered ${args.slideObjectIds.length} slide(s) to index ${args.insertionIndex}`,
+                });
+            } catch (error) {
+                log.error(`Error reordering slides: ${error.message || error}`);
+                throw new UserError(`Failed to reorder slides: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/replaceAllText.js

@@ -0,0 +1,46 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'replaceAllTextInSlides',
+        description:
+            'Find and replace all matching text across all slides in a Google Slides presentation.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            containsText: z.string().describe('Text to search for'),
+            replaceText: z.string().describe('Replacement text'),
+            matchCase: z.boolean().optional().default(false).describe('Case-sensitive match'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+
+            try {
+                const response = await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: {
+                        requests: [
+                            {
+                                replaceAllText: {
+                                    containsText: { text: args.containsText, matchCase: args.matchCase },
+                                    replaceText: args.replaceText,
+                                },
+                            },
+                        ],
+                    },
+                });
+
+                const count = response.data.replies?.[0]?.replaceAllText?.occurrencesChanged ?? 0;
+                return JSON.stringify({
+                    success: true,
+                    occurrencesChanged: count,
+                    message: `Replaced ${count} occurrence(s) of "${args.containsText}"`,
+                });
+            } catch (error) {
+                log.error(`Error replacing text: ${error.message || error}`);
+                throw new UserError(`Failed to replace text: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/setBackground.js

@@ -0,0 +1,58 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'setSlidesBackground',
+        description:
+            'Set the background color for one or more slides in a Google Slides presentation.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            pageObjectIds: z.array(z.string()).min(1).describe('Array of slide page object IDs to update'),
+            backgroundColor: z
+                .object({
+                    red: z.number().min(0).max(1).optional(),
+                    green: z.number().min(0).max(1).optional(),
+                    blue: z.number().min(0).max(1).optional(),
+                    alpha: z.number().min(0).max(1).optional(),
+                })
+                .describe('Background color (RGBA 0-1)'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+
+            const requests = args.pageObjectIds.map((pageObjectId) => ({
+                updatePageProperties: {
+                    objectId: pageObjectId,
+                    pageProperties: {
+                        pageBackgroundFill: {
+                            solidFill: {
+                                color: {
+                                    rgbColor: {
+                                        red: args.backgroundColor.red || 0,
+                                        green: args.backgroundColor.green || 0,
+                                        blue: args.backgroundColor.blue || 0,
+                                    },
+                                },
+                                alpha: args.backgroundColor.alpha ?? 1,
+                            },
+                        },
+                    },
+                    fields: 'pageBackgroundFill',
+                },
+            }));
+
+            try {
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: { requests },
+                });
+                return JSON.stringify({ success: true, message: `Set background for ${args.pageObjectIds.length} slide(s)` });
+            } catch (error) {
+                log.error(`Error setting background: ${error.message || error}`);
+                throw new UserError(`Failed to set background: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/speakerNotes.js

@@ -0,0 +1,102 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    // --- Get speaker notes ---
+    server.addTool({
+        name: 'getSpeakerNotes',
+        description: 'Get the speaker notes from a specific slide in a Google Slides presentation.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            slideIndex: z.number().min(0).describe('Slide index (0-based)'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+
+            try {
+                const presentation = await slidesApi.presentations.get({ presentationId: args.presentationId });
+                const allSlides = presentation.data.slides || [];
+
+                if (args.slideIndex >= allSlides.length) {
+                    throw new UserError(`Slide index ${args.slideIndex} out of range (presentation has ${allSlides.length} slides)`);
+                }
+
+                const slide = allSlides[args.slideIndex];
+                const notesObjectId = slide.slideProperties?.notesPage?.notesProperties?.speakerNotesObjectId;
+
+                if (!notesObjectId) {
+                    return JSON.stringify({ slideIndex: args.slideIndex, notes: '' });
+                }
+
+                const notesPage = slide.slideProperties?.notesPage;
+                const notesElement = notesPage?.pageElements?.find((el) => el.objectId === notesObjectId);
+
+                let notesText = '';
+                if (notesElement?.shape?.text?.textElements) {
+                    for (const te of notesElement.shape.text.textElements) {
+                        if (te.textRun?.content) notesText += te.textRun.content;
+                    }
+                }
+
+                return JSON.stringify({ slideIndex: args.slideIndex, notes: notesText.trim() });
+            } catch (error) {
+                if (error instanceof UserError) throw error;
+                log.error(`Error getting speaker notes: ${error.message || error}`);
+                throw new UserError(`Failed to get speaker notes: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+
+    // --- Update speaker notes ---
+    server.addTool({
+        name: 'updateSpeakerNotes',
+        description: 'Update the speaker notes for a specific slide in a Google Slides presentation.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            slideIndex: z.number().min(0).describe('Slide index (0-based)'),
+            notes: z.string().describe('Speaker notes content'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+
+            try {
+                const presentation = await slidesApi.presentations.get({ presentationId: args.presentationId });
+                const allSlides = presentation.data.slides || [];
+
+                if (args.slideIndex >= allSlides.length) {
+                    throw new UserError(`Slide index ${args.slideIndex} out of range (presentation has ${allSlides.length} slides)`);
+                }
+
+                const slide = allSlides[args.slideIndex];
+                const notesObjectId = slide.slideProperties?.notesPage?.notesProperties?.speakerNotesObjectId;
+
+                if (!notesObjectId) {
+                    throw new UserError('This slide does not have a speaker notes object.');
+                }
+
+                // Check if there's existing text to delete first
+                const notesPage = slide.slideProperties?.notesPage;
+                const notesElement = notesPage?.pageElements?.find((el) => el.objectId === notesObjectId);
+                const hasExistingText = notesElement?.shape?.text?.textElements?.some((el) => el.textRun?.content);
+
+                const requests = [];
+                if (hasExistingText) {
+                    requests.push({ deleteText: { objectId: notesObjectId, textRange: { type: 'ALL' } } });
+                }
+                requests.push({ insertText: { objectId: notesObjectId, text: args.notes, insertionIndex: 0 } });
+
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: { requests },
+                });
+
+                return JSON.stringify({ success: true, message: `Updated speaker notes for slide ${args.slideIndex}` });
+            } catch (error) {
+                if (error instanceof UserError) throw error;
+                log.error(`Error updating speaker notes: ${error.message || error}`);
+                throw new UserError(`Failed to update speaker notes: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/styleShape.js

@@ -0,0 +1,111 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'styleSlidesShape',
+        description:
+            'Style a shape in Google Slides: set background color, outline color/weight/dash style.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            objectId: z.string().describe('Shape object ID'),
+            backgroundColor: z
+                .object({
+                    red: z.number().min(0).max(1).optional(),
+                    green: z.number().min(0).max(1).optional(),
+                    blue: z.number().min(0).max(1).optional(),
+                    alpha: z.number().min(0).max(1).optional(),
+                })
+                .optional()
+                .describe('Fill color (RGBA 0-1)'),
+            outlineColor: z
+                .object({
+                    red: z.number().min(0).max(1).optional(),
+                    green: z.number().min(0).max(1).optional(),
+                    blue: z.number().min(0).max(1).optional(),
+                })
+                .optional()
+                .describe('Outline color (RGB 0-1)'),
+            outlineWeight: z.number().optional().describe('Outline thickness in points'),
+            outlineDashStyle: z
+                .enum(['SOLID', 'DOT', 'DASH', 'DASH_DOT', 'LONG_DASH', 'LONG_DASH_DOT'])
+                .optional()
+                .describe('Outline dash style'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+            const shapeProperties = {};
+            const fields = [];
+
+            if (args.backgroundColor) {
+                shapeProperties.shapeBackgroundFill = {
+                    solidFill: {
+                        color: {
+                            rgbColor: {
+                                red: args.backgroundColor.red || 0,
+                                green: args.backgroundColor.green || 0,
+                                blue: args.backgroundColor.blue || 0,
+                            },
+                        },
+                        alpha: args.backgroundColor.alpha ?? 1,
+                    },
+                };
+                fields.push('shapeBackgroundFill');
+            }
+
+            const outline = {};
+            let hasOutline = false;
+
+            if (args.outlineColor) {
+                outline.outlineFill = {
+                    solidFill: {
+                        color: {
+                            rgbColor: {
+                                red: args.outlineColor.red || 0,
+                                green: args.outlineColor.green || 0,
+                                blue: args.outlineColor.blue || 0,
+                            },
+                        },
+                    },
+                };
+                hasOutline = true;
+            }
+            if (args.outlineWeight !== undefined) {
+                outline.weight = { magnitude: args.outlineWeight, unit: 'PT' };
+                hasOutline = true;
+            }
+            if (args.outlineDashStyle) {
+                outline.dashStyle = args.outlineDashStyle;
+                hasOutline = true;
+            }
+            if (hasOutline) {
+                shapeProperties.outline = outline;
+                fields.push('outline');
+            }
+
+            if (fields.length === 0) throw new UserError('No styling options specified');
+
+            try {
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: {
+                        requests: [
+                            {
+                                updateShapeProperties: {
+                                    objectId: args.objectId,
+                                    shapeProperties,
+                                    fields: fields.join(','),
+                                },
+                            },
+                        ],
+                    },
+                });
+                return JSON.stringify({ success: true, message: `Applied styling to shape ${args.objectId}` });
+            } catch (error) {
+                log.error(`Error styling shape: ${error.message || error}`);
+                throw new UserError(`Failed to style shape: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/slides/updatePresentation.js

@@ -0,0 +1,128 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getSlidesClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'updatePresentation',
+        description:
+            'Replace all slides in an existing Google Slides presentation with new content. Deletes existing slides and creates new ones with the provided title/content pairs.',
+        parameters: z.object({
+            presentationId: z.string().describe('Presentation ID'),
+            slides: z
+                .array(
+                    z.object({
+                        title: z.string().describe('Slide title'),
+                        content: z.string().describe('Slide body content'),
+                    }),
+                )
+                .min(1)
+                .describe('Array of slide objects to replace existing slides'),
+        }),
+        execute: async (args, { log }) => {
+            const slidesApi = await getSlidesClient();
+            log.info(`Updating presentation: ${args.presentationId}`);
+
+            try {
+                const currentPresentation = await slidesApi.presentations.get({
+                    presentationId: args.presentationId,
+                });
+
+                if (!currentPresentation.data.slides) {
+                    throw new UserError('No slides found in presentation');
+                }
+
+                // Delete all slides except the first, then clear and rewrite the first
+                const slideIdsToDelete = currentPresentation.data.slides
+                    .slice(1)
+                    .map((s) => s.objectId)
+                    .filter(Boolean);
+
+                const requests = [];
+
+                // Delete extra slides
+                for (const id of slideIdsToDelete) {
+                    requests.push({ deleteObject: { objectId: id } });
+                }
+
+                // Clear text from the first slide's text elements
+                const firstSlide = currentPresentation.data.slides[0];
+                if (firstSlide?.pageElements) {
+                    for (const el of firstSlide.pageElements) {
+                        if (el.objectId && el.shape?.text) {
+                            requests.push({ deleteText: { objectId: el.objectId, textRange: { type: 'ALL' } } });
+                        }
+                    }
+                }
+
+                // Insert new content into first slide
+                const firstContent = args.slides[0];
+                if (firstSlide?.pageElements) {
+                    let titleId, bodyId;
+                    for (const el of firstSlide.pageElements) {
+                        const pt = el.shape?.placeholder?.type;
+                        if (pt === 'TITLE' || pt === 'CENTERED_TITLE') titleId = el.objectId;
+                        else if (pt === 'BODY' || pt === 'SUBTITLE') bodyId = el.objectId;
+                    }
+                    if (titleId) requests.push({ insertText: { objectId: titleId, text: firstContent.title, insertionIndex: 0 } });
+                    if (bodyId) requests.push({ insertText: { objectId: bodyId, text: firstContent.content, insertionIndex: 0 } });
+                }
+
+                // Create additional slides
+                for (let i = 1; i < args.slides.length; i++) {
+                    requests.push({
+                        createSlide: {
+                            objectId: `slide_${Date.now()}_${i}`,
+                            slideLayoutReference: { predefinedLayout: 'TITLE_AND_BODY' },
+                        },
+                    });
+                }
+
+                await slidesApi.presentations.batchUpdate({
+                    presentationId: args.presentationId,
+                    requestBody: { requests },
+                });
+
+                // Populate new slides (index 1+)
+                if (args.slides.length > 1) {
+                    const updated = await slidesApi.presentations.get({ presentationId: args.presentationId });
+                    const contentRequests = [];
+                    for (let i = 1; i < args.slides.length && updated.data.slides; i++) {
+                        const slide = args.slides[i];
+                        const pageSlide = updated.data.slides[i];
+                        if (!pageSlide?.pageElements) continue;
+                        for (const el of pageSlide.pageElements) {
+                            if (!el.objectId) continue;
+                            const pt = el.shape?.placeholder?.type;
+                            if (pt === 'TITLE' || pt === 'CENTERED_TITLE') {
+                                contentRequests.push({ insertText: { objectId: el.objectId, text: slide.title, insertionIndex: 0 } });
+                            } else if (pt === 'BODY' || pt === 'SUBTITLE') {
+                                contentRequests.push({ insertText: { objectId: el.objectId, text: slide.content, insertionIndex: 0 } });
+                            }
+                        }
+                    }
+                    if (contentRequests.length > 0) {
+                        await slidesApi.presentations.batchUpdate({
+                            presentationId: args.presentationId,
+                            requestBody: { requests: contentRequests },
+                        });
+                    }
+                }
+
+                return JSON.stringify(
+                    {
+                        presentationId: args.presentationId,
+                        slidesUpdated: args.slides.length,
+                        link: `https://docs.google.com/presentation/d/${args.presentationId}`,
+                    },
+                    null,
+                    2,
+                );
+            } catch (error) {
+                if (error instanceof UserError) throw error;
+                log.error(`Error updating presentation: ${error.message || error}`);
+                throw new UserError(`Failed to update presentation: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "google-tools-mcp",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "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": {