google-tools-mcp 1.1.1 → 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'}`);
+            }
+        },
+    });
+}