@piotr-agier/google-drive-mcp 1.4.0 → 1.5.0

package/README.md

@@ -569,9 +569,41 @@ Add the server to your Claude Desktop configuration:
   - `valueInputOption`: `RAW` or `USER_ENTERED` (optional, default: USER_ENTERED)
 
 - **addSpreadsheetSheet** - Add a new sheet/tab to an existing spreadsheet
+- **addSheet** - Alias for `addSpreadsheetSheet`
   - `spreadsheetId`: Spreadsheet ID
   - `sheetTitle`: Title for the new sheet
 
+- **listSheets** - List tabs/sheets in a spreadsheet
+  - `spreadsheetId`: Spreadsheet ID
+
+- **renameSheet** - Rename a sheet/tab by `sheetId`
+  - `spreadsheetId`: Spreadsheet ID
+  - `sheetId`: Sheet ID
+  - `newTitle`: New title
+
+- **deleteSheet** - Delete a sheet/tab by `sheetId`
+  - `spreadsheetId`: Spreadsheet ID
+  - `sheetId`: Sheet ID
+
+- **addDataValidation** - Add data validation rules to a range
+  - `spreadsheetId`: Spreadsheet ID
+  - `range`: A1 range (e.g., `Sheet1!A1:A10`)
+  - `conditionType`: `ONE_OF_LIST`, `NUMBER_GREATER`, `NUMBER_LESS`, or `TEXT_CONTAINS`
+  - `values`: Condition values (e.g. list items, threshold)
+  - `strict`: Reject invalid values (optional, default: `true`)
+  - `showCustomUi`: Show dropdown/custom UI (optional, default: `true`)
+
+- **protectRange** - Protect a range in a spreadsheet
+  - `spreadsheetId`: Spreadsheet ID
+  - `range`: A1 range
+  - `description`: Protection description (optional)
+  - `warningOnly`: Warn instead of enforce (optional, default: `false`)
+
+- **addNamedRange** - Create a named range
+  - `spreadsheetId`: Spreadsheet ID
+  - `name`: Named range name
+  - `range`: A1 range
+
 - **listGoogleSheets** - List Google Spreadsheets with optional filtering
   - `query`: Search query to filter by name or content (optional)
   - `maxResults`: Maximum spreadsheets to return, 1-100 (optional, default: 20)
@@ -694,6 +726,32 @@ Add the server to your Claude Desktop configuration:
   - `slideIndex`: Slide index (0-based)
   - `notes`: The speaker notes content to set
 
+#### Slide Operations and Templating
+- **deleteGoogleSlide** - Delete a slide by object ID
+  - `presentationId`: Presentation ID
+  - `slideObjectId`: Slide object ID
+
+- **duplicateSlide** - Duplicate a slide by object ID
+  - `presentationId`: Presentation ID
+  - `slideObjectId`: Slide object ID
+
+- **reorderSlides** - Reorder slides by object IDs and insertion index
+  - `presentationId`: Presentation ID
+  - `slideObjectIds`: Array of slide object IDs to move
+  - `insertionIndex`: Target insertion index
+
+- **replaceAllTextInSlides** - Replace text across a presentation
+  - `presentationId`: Presentation ID
+  - `containsText`: Text to find
+  - `replaceText`: Replacement text
+  - `matchCase`: Match case (optional, default: `false`)
+
+- **exportSlideThumbnail** - Export a slide thumbnail URL (PNG/JPEG, SMALL/MEDIUM/LARGE)
+  - `presentationId`: Presentation ID
+  - `slideObjectId`: Slide object ID
+  - `mimeType`: `PNG` or `JPEG` (optional, default: `PNG`)
+  - `size`: `SMALL`, `MEDIUM`, or `LARGE` (optional, default: `LARGE`)
+
 ### Google Calendar
 - **listCalendars** - List all accessible Google Calendars
   - `showHidden`: Include hidden calendars (optional, default: false)

package/dist/index.js

@@ -1589,7 +1589,7 @@ Link: ${response.data.webViewLink}` }],
       const data = validation.data;
       const response = await ctx.getDrive().permissions.list({
         fileId: data.fileId,
-        fields: "permissions(id,type,role,emailAddress,domain,displayName)",
+        fields: "permissions(id,type,role,emailAddress,domain,displayName,permissionDetails(inherited,inheritedFrom,permissionType))",
         supportsAllDrives: true
       });
       const permissions = response.data.permissions || [];
@@ -1598,7 +1598,10 @@ Link: ${response.data.webViewLink}` }],
       }
       const lines = permissions.map((p) => {
         const who = p.emailAddress || p.domain || p.displayName || p.type || "unknown";
-        return `- ${p.id}: ${who} (${p.type}) => ${p.role}`;
+        const inherited = p.permissionDetails?.some((d) => d.inherited === true) ?? false;
+        const inheritedFrom = p.permissionDetails?.find((d) => d.inheritedFrom)?.inheritedFrom;
+        const inheritedMarker = inherited ? ` [inherited${inheritedFrom ? ` from ${inheritedFrom}` : ""}]` : " [direct]";
+        return `- ${p.id}: ${who} (${p.type}) => ${p.role}${inheritedMarker}`;
       });
       return { content: [{ type: "text", text: `Permissions for file ${data.fileId}:
 ${lines.join("\n")}` }], isError: false };
@@ -3776,6 +3779,41 @@ var AddSpreadsheetSheetSchema = z3.object({
   spreadsheetId: z3.string().min(1, "Spreadsheet ID is required"),
   sheetTitle: z3.string().min(1, "Sheet title is required")
 });
+var AddSheetSchema = z3.object({
+  spreadsheetId: z3.string().min(1, "Spreadsheet ID is required"),
+  title: z3.string().min(1, "Sheet title is required")
+});
+var ListSheetsSchema = z3.object({
+  spreadsheetId: z3.string().min(1, "Spreadsheet ID is required")
+});
+var RenameSheetSchema = z3.object({
+  spreadsheetId: z3.string().min(1, "Spreadsheet ID is required"),
+  sheetId: z3.number().int(),
+  newTitle: z3.string().min(1, "New title is required")
+});
+var DeleteSheetSchema = z3.object({
+  spreadsheetId: z3.string().min(1, "Spreadsheet ID is required"),
+  sheetId: z3.number().int()
+});
+var AddDataValidationSchema = z3.object({
+  spreadsheetId: z3.string().min(1, "Spreadsheet ID is required"),
+  range: z3.string().min(1, "Range is required"),
+  conditionType: z3.enum(["ONE_OF_LIST", "NUMBER_GREATER", "NUMBER_LESS", "TEXT_CONTAINS"]),
+  values: z3.array(z3.string()).min(1, "At least one value is required"),
+  strict: z3.boolean().optional().default(true),
+  showCustomUi: z3.boolean().optional().default(true)
+});
+var ProtectRangeSchema = z3.object({
+  spreadsheetId: z3.string().min(1, "Spreadsheet ID is required"),
+  range: z3.string().min(1, "Range is required"),
+  description: z3.string().optional(),
+  warningOnly: z3.boolean().optional().default(false)
+});
+var AddNamedRangeSchema = z3.object({
+  spreadsheetId: z3.string().min(1, "Spreadsheet ID is required"),
+  name: z3.string().min(1, "Name is required"),
+  range: z3.string().min(1, "Range is required")
+});
 var ListGoogleSheetsSchema = z3.object({
   maxResults: z3.number().int().min(1).max(100).optional().default(20),
   query: z3.string().optional(),
@@ -4061,6 +4099,97 @@ var toolDefinitions3 = [
       required: ["spreadsheetId", "sheetTitle"]
     }
   },
+  {
+    name: "addSheet",
+    description: "Alias for addSpreadsheetSheet (adds a new sheet/tab)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        spreadsheetId: { type: "string", description: "Spreadsheet ID" },
+        title: { type: "string", description: "Title for the new sheet/tab" }
+      },
+      required: ["spreadsheetId", "title"]
+    }
+  },
+  {
+    name: "listSheets",
+    description: "List tabs/sheets in a Google Spreadsheet",
+    inputSchema: {
+      type: "object",
+      properties: {
+        spreadsheetId: { type: "string", description: "Spreadsheet ID" }
+      },
+      required: ["spreadsheetId"]
+    }
+  },
+  {
+    name: "renameSheet",
+    description: "Rename a sheet/tab by sheetId",
+    inputSchema: {
+      type: "object",
+      properties: {
+        spreadsheetId: { type: "string", description: "Spreadsheet ID" },
+        sheetId: { type: "number", description: "Sheet ID" },
+        newTitle: { type: "string", description: "New title" }
+      },
+      required: ["spreadsheetId", "sheetId", "newTitle"]
+    }
+  },
+  {
+    name: "deleteSheet",
+    description: "Delete a sheet/tab by sheetId",
+    inputSchema: {
+      type: "object",
+      properties: {
+        spreadsheetId: { type: "string", description: "Spreadsheet ID" },
+        sheetId: { type: "number", description: "Sheet ID" }
+      },
+      required: ["spreadsheetId", "sheetId"]
+    }
+  },
+  {
+    name: "addDataValidation",
+    description: "Add data validation rules to a sheet range",
+    inputSchema: {
+      type: "object",
+      properties: {
+        spreadsheetId: { type: "string", description: "Spreadsheet ID" },
+        range: { type: "string", description: "A1 range" },
+        conditionType: { type: "string", enum: ["ONE_OF_LIST", "NUMBER_GREATER", "NUMBER_LESS", "TEXT_CONTAINS"], description: "Validation condition type" },
+        values: { type: "array", items: { type: "string" }, description: "Condition values (e.g. list items, threshold)" },
+        strict: { type: "boolean", description: "Reject invalid values" },
+        showCustomUi: { type: "boolean", description: "Show dropdown/custom UI" }
+      },
+      required: ["spreadsheetId", "range", "conditionType", "values"]
+    }
+  },
+  {
+    name: "protectRange",
+    description: "Protect a range in a spreadsheet",
+    inputSchema: {
+      type: "object",
+      properties: {
+        spreadsheetId: { type: "string", description: "Spreadsheet ID" },
+        range: { type: "string", description: "A1 range" },
+        description: { type: "string", description: "Protection description" },
+        warningOnly: { type: "boolean", description: "Warn instead of enforce" }
+      },
+      required: ["spreadsheetId", "range"]
+    }
+  },
+  {
+    name: "addNamedRange",
+    description: "Create a named range",
+    inputSchema: {
+      type: "object",
+      properties: {
+        spreadsheetId: { type: "string", description: "Spreadsheet ID" },
+        name: { type: "string", description: "Named range name" },
+        range: { type: "string", description: "A1 range" }
+      },
+      required: ["spreadsheetId", "name", "range"]
+    }
+  },
   {
     name: "listGoogleSheets",
     description: "Lists Google Spreadsheets from your Google Drive with optional filtering",
@@ -4075,6 +4204,19 @@ var toolDefinitions3 = [
     }
   }
 ];
+async function resolveGridRange(sheetsService, spreadsheetId, range) {
+  const rangeData = await sheetsService.spreadsheets.get({
+    spreadsheetId,
+    ranges: [range],
+    fields: "sheets(properties(sheetId,title))"
+  });
+  const { sheetName, cellRange: a1Range } = parseA1Range(range);
+  const sheet = rangeData.data.sheets?.find((s) => s.properties?.title === sheetName);
+  if (!sheet || sheet.properties?.sheetId === void 0 || sheet.properties?.sheetId === null) {
+    return `Sheet "${sheetName}" not found`;
+  }
+  return convertA1ToGridRange(a1Range, sheet.properties.sheetId);
+}
 async function handleTool3(toolName, args, ctx) {
   switch (toolName) {
     case "createGoogleSheet": {
@@ -4569,20 +4711,23 @@ ID: ${spreadsheet.data.spreadsheetId}` }],
         isError: false
       };
     }
-    case "addSpreadsheetSheet": {
-      const validation = AddSpreadsheetSheetSchema.safeParse(args);
+    case "addSpreadsheetSheet":
+    case "addSheet": {
+      const isAlias = toolName === "addSheet";
+      const validation = isAlias ? AddSheetSchema.safeParse(args) : AddSpreadsheetSheetSchema.safeParse(args);
       if (!validation.success) {
         return errorResponse(validation.error.errors[0].message);
       }
-      const a = validation.data;
+      const spreadsheetId = validation.data.spreadsheetId;
+      const sheetTitle = isAlias ? validation.data.title : validation.data.sheetTitle;
       const sheets = ctx.google.sheets({ version: "v4", auth: ctx.authClient });
       const response = await sheets.spreadsheets.batchUpdate({
-        spreadsheetId: a.spreadsheetId,
+        spreadsheetId,
         requestBody: {
           requests: [{
             addSheet: {
               properties: {
-                title: a.sheetTitle
+                title: sheetTitle
               }
             }
           }]
@@ -4597,6 +4742,131 @@ ID: ${spreadsheet.data.spreadsheetId}` }],
         isError: false
       };
     }
+    case "listSheets": {
+      const validation = ListSheetsSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const a = validation.data;
+      const sheets = ctx.google.sheets({ version: "v4", auth: ctx.authClient });
+      const response = await sheets.spreadsheets.get({
+        spreadsheetId: a.spreadsheetId,
+        fields: "sheets.properties(sheetId,title,index,hidden)"
+      });
+      const tabs = response.data.sheets || [];
+      if (tabs.length === 0) {
+        return { content: [{ type: "text", text: "No sheets found." }], isError: false };
+      }
+      const lines = tabs.map((s) => `- ${s.properties?.title} (id: ${s.properties?.sheetId}, index: ${s.properties?.index}${s.properties?.hidden ? ", hidden" : ""})`);
+      return { content: [{ type: "text", text: `Sheets in spreadsheet ${a.spreadsheetId}:
+${lines.join("\n")}` }], isError: false };
+    }
+    case "renameSheet": {
+      const validation = RenameSheetSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const a = validation.data;
+      const sheets = ctx.google.sheets({ version: "v4", auth: ctx.authClient });
+      await sheets.spreadsheets.batchUpdate({
+        spreadsheetId: a.spreadsheetId,
+        requestBody: {
+          requests: [{
+            updateSheetProperties: {
+              properties: { sheetId: a.sheetId, title: a.newTitle },
+              fields: "title"
+            }
+          }]
+        }
+      });
+      return { content: [{ type: "text", text: `Renamed sheet ${a.sheetId} to "${a.newTitle}".` }], isError: false };
+    }
+    case "deleteSheet": {
+      const validation = DeleteSheetSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const a = validation.data;
+      const sheets = ctx.google.sheets({ version: "v4", auth: ctx.authClient });
+      await sheets.spreadsheets.batchUpdate({
+        spreadsheetId: a.spreadsheetId,
+        requestBody: {
+          requests: [{
+            deleteSheet: { sheetId: a.sheetId }
+          }]
+        }
+      });
+      return { content: [{ type: "text", text: `Deleted sheet ${a.sheetId}.` }], isError: false };
+    }
+    case "addDataValidation": {
+      const validation = AddDataValidationSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const a = validation.data;
+      const sheets = ctx.google.sheets({ version: "v4", auth: ctx.authClient });
+      const gridRange = await resolveGridRange(sheets, a.spreadsheetId, a.range);
+      if (typeof gridRange === "string") return errorResponse(gridRange);
+      const conditionValues = a.values.map((v) => ({ userEnteredValue: v }));
+      await sheets.spreadsheets.batchUpdate({
+        spreadsheetId: a.spreadsheetId,
+        requestBody: {
+          requests: [{
+            setDataValidation: {
+              range: gridRange,
+              rule: {
+                condition: {
+                  type: a.conditionType,
+                  values: conditionValues
+                },
+                strict: a.strict,
+                showCustomUi: a.showCustomUi
+              }
+            }
+          }]
+        }
+      });
+      return { content: [{ type: "text", text: `Added data validation (${a.conditionType}) to ${a.range}.` }], isError: false };
+    }
+    case "protectRange": {
+      const validation = ProtectRangeSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const a = validation.data;
+      const sheets = ctx.google.sheets({ version: "v4", auth: ctx.authClient });
+      const gridRange = await resolveGridRange(sheets, a.spreadsheetId, a.range);
+      if (typeof gridRange === "string") return errorResponse(gridRange);
+      const response = await sheets.spreadsheets.batchUpdate({
+        spreadsheetId: a.spreadsheetId,
+        requestBody: {
+          requests: [{
+            addProtectedRange: {
+              protectedRange: {
+                range: gridRange,
+                description: a.description,
+                warningOnly: a.warningOnly
+              }
+            }
+          }]
+        }
+      });
+      const protectedRangeId = response.data.replies?.[0]?.addProtectedRange?.protectedRange?.protectedRangeId;
+      return { content: [{ type: "text", text: `Protected range ${a.range}${protectedRangeId ? ` (id: ${protectedRangeId})` : ""}.` }], isError: false };
+    }
+    case "addNamedRange": {
+      const validation = AddNamedRangeSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const a = validation.data;
+      const sheets = ctx.google.sheets({ version: "v4", auth: ctx.authClient });
+      const gridRange = await resolveGridRange(sheets, a.spreadsheetId, a.range);
+      if (typeof gridRange === "string") return errorResponse(gridRange);
+      const response = await sheets.spreadsheets.batchUpdate({
+        spreadsheetId: a.spreadsheetId,
+        requestBody: {
+          requests: [{
+            addNamedRange: {
+              namedRange: {
+                name: a.name,
+                range: gridRange
+              }
+            }
+          }]
+        }
+      });
+      const namedRangeId = response.data.replies?.[0]?.addNamedRange?.namedRange?.namedRangeId;
+      return { content: [{ type: "text", text: `Added named range "${a.name}" for ${a.range}${namedRangeId ? ` (id: ${namedRangeId})` : ""}.` }], isError: false };
+    }
     case "listGoogleSheets": {
       const validation = ListGoogleSheetsSchema.safeParse(args);
       if (!validation.success) {
@@ -4766,6 +5036,31 @@ var UpdateGoogleSlidesSpeakerNotesSchema = z4.object({
   slideIndex: z4.number().min(0, "Slide index must be non-negative"),
   notes: z4.string()
 });
+var DeleteGoogleSlideSchema = z4.object({
+  presentationId: z4.string().min(1, "Presentation ID is required"),
+  slideObjectId: z4.string().min(1, "Slide object ID is required")
+});
+var DuplicateSlideSchema = z4.object({
+  presentationId: z4.string().min(1, "Presentation ID is required"),
+  slideObjectId: z4.string().min(1, "Slide object ID is required")
+});
+var ReorderSlidesSchema = z4.object({
+  presentationId: z4.string().min(1, "Presentation ID is required"),
+  slideObjectIds: z4.array(z4.string().min(1)).min(1, "At least one slide object ID is required"),
+  insertionIndex: z4.number().int().min(0)
+});
+var ReplaceAllTextInSlidesSchema = z4.object({
+  presentationId: z4.string().min(1, "Presentation ID is required"),
+  containsText: z4.string().min(1, "containsText is required"),
+  replaceText: z4.string(),
+  matchCase: z4.boolean().optional().default(false)
+});
+var ExportSlideThumbnailSchema = z4.object({
+  presentationId: z4.string().min(1, "Presentation ID is required"),
+  slideObjectId: z4.string().min(1, "Slide object ID is required"),
+  mimeType: z4.enum(["PNG", "JPEG"]).optional().default("PNG"),
+  size: z4.enum(["SMALL", "MEDIUM", "LARGE"]).optional().default("LARGE")
+});
 var toolDefinitions4 = [
   {
     name: "createGoogleSlides",
@@ -5014,6 +5309,71 @@ var toolDefinitions4 = [
       },
       required: ["presentationId", "slideIndex", "notes"]
     }
+  },
+  {
+    name: "deleteGoogleSlide",
+    description: "Delete a slide from a presentation",
+    inputSchema: {
+      type: "object",
+      properties: {
+        presentationId: { type: "string", description: "Presentation ID" },
+        slideObjectId: { type: "string", description: "Slide object ID" }
+      },
+      required: ["presentationId", "slideObjectId"]
+    }
+  },
+  {
+    name: "duplicateSlide",
+    description: "Duplicate a slide in a presentation",
+    inputSchema: {
+      type: "object",
+      properties: {
+        presentationId: { type: "string", description: "Presentation ID" },
+        slideObjectId: { type: "string", description: "Slide object ID" }
+      },
+      required: ["presentationId", "slideObjectId"]
+    }
+  },
+  {
+    name: "reorderSlides",
+    description: "Reorder one or more slides in a presentation",
+    inputSchema: {
+      type: "object",
+      properties: {
+        presentationId: { type: "string", description: "Presentation ID" },
+        slideObjectIds: { type: "array", items: { type: "string" }, description: "Slide object IDs to move" },
+        insertionIndex: { type: "number", description: "Target insertion index" }
+      },
+      required: ["presentationId", "slideObjectIds", "insertionIndex"]
+    }
+  },
+  {
+    name: "replaceAllTextInSlides",
+    description: "Replace all matching text across presentation slides",
+    inputSchema: {
+      type: "object",
+      properties: {
+        presentationId: { type: "string", description: "Presentation ID" },
+        containsText: { type: "string", description: "Text to find" },
+        replaceText: { type: "string", description: "Replacement text" },
+        matchCase: { type: "boolean", description: "Case-sensitive match" }
+      },
+      required: ["presentationId", "containsText", "replaceText"]
+    }
+  },
+  {
+    name: "exportSlideThumbnail",
+    description: "Export a slide thumbnail URL",
+    inputSchema: {
+      type: "object",
+      properties: {
+        presentationId: { type: "string", description: "Presentation ID" },
+        slideObjectId: { type: "string", description: "Slide object ID" },
+        mimeType: { type: "string", enum: ["PNG", "JPEG"], description: "Thumbnail MIME type" },
+        size: { type: "string", enum: ["SMALL", "MEDIUM", "LARGE"], description: "Thumbnail size" }
+      },
+      required: ["presentationId", "slideObjectId"]
+    }
   }
 ];
 async function handleTool4(toolName, args, ctx) {
@@ -5758,6 +6118,103 @@ Slide ${a.slideIndex ?? index} (ID: ${slide.objectId}):
         isError: false
       };
     }
+    case "deleteGoogleSlide": {
+      const validation = DeleteGoogleSlideSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const a = validation.data;
+      const slidesService = ctx.google.slides({ version: "v1", auth: ctx.authClient });
+      await slidesService.presentations.batchUpdate({
+        presentationId: a.presentationId,
+        requestBody: {
+          requests: [{ deleteObject: { objectId: a.slideObjectId } }]
+        }
+      });
+      return {
+        content: [{ type: "text", text: `Deleted slide ${a.slideObjectId}` }],
+        isError: false
+      };
+    }
+    case "duplicateSlide": {
+      const validation = DuplicateSlideSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const a = validation.data;
+      const slidesService = ctx.google.slides({ version: "v1", auth: ctx.authClient });
+      const response = await slidesService.presentations.batchUpdate({
+        presentationId: a.presentationId,
+        requestBody: {
+          requests: [{ duplicateObject: { objectId: a.slideObjectId } }]
+        }
+      });
+      const dupId = response.data.replies?.[0]?.duplicateObject?.objectId;
+      return {
+        content: [{ type: "text", text: `Duplicated slide ${a.slideObjectId}${dupId ? ` -> ${dupId}` : ""}` }],
+        isError: false
+      };
+    }
+    case "reorderSlides": {
+      const validation = ReorderSlidesSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const a = validation.data;
+      const slidesService = ctx.google.slides({ version: "v1", auth: ctx.authClient });
+      await slidesService.presentations.batchUpdate({
+        presentationId: a.presentationId,
+        requestBody: {
+          requests: [{
+            updateSlidesPosition: {
+              slideObjectIds: a.slideObjectIds,
+              insertionIndex: a.insertionIndex
+            }
+          }]
+        }
+      });
+      return {
+        content: [{ type: "text", text: `Reordered ${a.slideObjectIds.length} slide(s) to index ${a.insertionIndex}` }],
+        isError: false
+      };
+    }
+    case "replaceAllTextInSlides": {
+      const validation = ReplaceAllTextInSlidesSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const a = validation.data;
+      const slidesService = ctx.google.slides({ version: "v1", auth: ctx.authClient });
+      const response = await slidesService.presentations.batchUpdate({
+        presentationId: a.presentationId,
+        requestBody: {
+          requests: [{
+            replaceAllText: {
+              containsText: {
+                text: a.containsText,
+                matchCase: a.matchCase
+              },
+              replaceText: a.replaceText
+            }
+          }]
+        }
+      });
+      const count = response.data.replies?.[0]?.replaceAllText?.occurrencesChanged ?? 0;
+      return {
+        content: [{ type: "text", text: `Replaced ${count} occurrence(s) of "${a.containsText}" in slides.` }],
+        isError: false
+      };
+    }
+    case "exportSlideThumbnail": {
+      const validation = ExportSlideThumbnailSchema.safeParse(args);
+      if (!validation.success) return errorResponse(validation.error.errors[0].message);
+      const a = validation.data;
+      const slidesService = ctx.google.slides({ version: "v1", auth: ctx.authClient });
+      const response = await slidesService.presentations.pages.getThumbnail({
+        presentationId: a.presentationId,
+        pageObjectId: a.slideObjectId,
+        "thumbnailProperties.mimeType": a.mimeType,
+        "thumbnailProperties.thumbnailSize": a.size
+      });
+      const url = response.data?.contentUrl;
+      if (!url) return errorResponse("No thumbnail URL returned by Google Slides API.");
+      return {
+        content: [{ type: "text", text: `Slide thumbnail URL (${a.mimeType}, ${a.size}): ${url}` }],
+        isError: false
+      };
+    }
     default:
       return null;
   }