mcp-google-extras 1.0.0

package/dist/tools/docs/addTab.js

@@ -0,0 +1,92 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDocsClient } from '../../clients.js';
+import { DocumentIdParameter } from '../../types.js';
+import * as GDocsHelpers from '../../googleDocsApiHelpers.js';
+export function register(server) {
+    server.addTool({
+        name: 'addTab',
+        description: "Adds a new tab to a Google Docs document. Optionally set the tab title, position, parent tab (for nesting), and icon emoji. Returns the new tab's ID and properties.",
+        parameters: DocumentIdParameter.extend({
+            title: z
+                .string()
+                .optional()
+                .describe('The title for the new tab. If not specified, Google Docs assigns a default name.'),
+            parentTabId: z
+                .string()
+                .optional()
+                .describe('The ID of an existing tab to nest this new tab under as a child. Use listDocumentTabs to get tab IDs. If not specified, the tab is created at the root level.'),
+            index: z
+                .number()
+                .int()
+                .min(0)
+                .optional()
+                .describe('The zero-based position among sibling tabs (within the same parent). If not specified, the tab is added at the end.'),
+            iconEmoji: z
+                .string()
+                .optional()
+                .describe('An emoji to display as the tab icon (e.g., "📋").'),
+        }),
+        execute: async (args, { log }) => {
+            const docs = await getDocsClient();
+            log.info(`Adding new tab to doc ${args.documentId}`);
+            try {
+                // If parentTabId is provided, verify it exists
+                if (args.parentTabId) {
+                    const docInfo = await docs.documents.get({
+                        documentId: args.documentId,
+                        includeTabsContent: true,
+                        fields: 'tabs(tabProperties,documentTab)',
+                    });
+                    const parentTab = GDocsHelpers.findTabById(docInfo.data, args.parentTabId);
+                    if (!parentTab) {
+                        throw new UserError(`Parent tab with ID "${args.parentTabId}" not found in document.`);
+                    }
+                }
+                const tabProperties = {};
+                if (args.title !== undefined)
+                    tabProperties.title = args.title;
+                if (args.parentTabId !== undefined)
+                    tabProperties.parentTabId = args.parentTabId;
+                if (args.index !== undefined)
+                    tabProperties.index = args.index;
+                if (args.iconEmoji !== undefined)
+                    tabProperties.iconEmoji = args.iconEmoji;
+                const response = await docs.documents.batchUpdate({
+                    documentId: args.documentId,
+                    requestBody: {
+                        requests: [
+                            {
+                                addDocumentTab: {
+                                    tabProperties,
+                                },
+                            },
+                        ],
+                    },
+                });
+                const newTabProps = response.data.replies?.[0]?.addDocumentTab?.tabProperties;
+                if (newTabProps) {
+                    return JSON.stringify({
+                        message: `Successfully added new tab "${newTabProps.title || '(untitled)'}"`,
+                        tabId: newTabProps.tabId,
+                        title: newTabProps.title,
+                        index: newTabProps.index,
+                        parentTabId: newTabProps.parentTabId,
+                        nestingLevel: newTabProps.nestingLevel,
+                    }, null, 2);
+                }
+                return 'Tab created successfully, but could not retrieve the new tab details.';
+            }
+            catch (error) {
+                log.error(`Error adding tab to doc ${args.documentId}: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                if (error.code === 404)
+                    throw new UserError(`Document not found (ID: ${args.documentId}).`);
+                if (error.code === 403)
+                    throw new UserError(`Permission denied for document (ID: ${args.documentId}).`);
+                throw new UserError(`Failed to add tab: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/docs/appendToGoogleDoc.js

@@ -0,0 +1,81 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDocsClient } from '../../clients.js';
+import { DocumentIdParameter, NotImplementedError } from '../../types.js';
+import * as GDocsHelpers from '../../googleDocsApiHelpers.js';
+export function register(server) {
+    server.addTool({
+        name: 'appendText',
+        description: 'Appends plain text to the end of a document. For formatted content, use appendMarkdown instead.',
+        parameters: DocumentIdParameter.extend({
+            text: z.string().min(1).describe('The plain text to append to the end of the document.'),
+            addNewlineIfNeeded: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe("Automatically add a newline before the appended text if the doc doesn't end with one."),
+            tabId: z
+                .string()
+                .optional()
+                .describe('The ID of the specific tab to append to. If not specified, appends to the first tab (or legacy document.body for documents without tabs).'),
+        }),
+        execute: async (args, { log }) => {
+            const docs = await getDocsClient();
+            log.info(`Appending to Google Doc: ${args.documentId}${args.tabId ? ` (tab: ${args.tabId})` : ''}`);
+            try {
+                // Determine if we need tabs content
+                const needsTabsContent = !!args.tabId;
+                // Get the current end index
+                const docInfo = await docs.documents.get({
+                    documentId: args.documentId,
+                    includeTabsContent: needsTabsContent,
+                    fields: needsTabsContent ? 'tabs' : 'body(content(endIndex)),documentStyle(pageSize)',
+                });
+                let endIndex = 1;
+                let bodyContent;
+                // If tabId is specified, find the specific tab
+                if (args.tabId) {
+                    const targetTab = GDocsHelpers.findTabById(docInfo.data, args.tabId);
+                    if (!targetTab) {
+                        throw new UserError(`Tab with ID "${args.tabId}" not found in document.`);
+                    }
+                    if (!targetTab.documentTab) {
+                        throw new UserError(`Tab "${args.tabId}" does not have content (may not be a document tab).`);
+                    }
+                    bodyContent = targetTab.documentTab.body?.content;
+                }
+                else {
+                    bodyContent = docInfo.data.body?.content;
+                }
+                if (bodyContent) {
+                    const lastElement = bodyContent[bodyContent.length - 1];
+                    if (lastElement?.endIndex) {
+                        endIndex = lastElement.endIndex - 1; // Insert *before* the final newline of the doc typically
+                    }
+                }
+                // Simpler approach: Always assume insertion is needed unless explicitly told not to add newline
+                const textToInsert = (args.addNewlineIfNeeded && endIndex > 1 ? '\n' : '') + args.text;
+                if (!textToInsert)
+                    return 'Nothing to append.';
+                const location = { index: endIndex };
+                if (args.tabId) {
+                    location.tabId = args.tabId;
+                }
+                const request = {
+                    insertText: { location, text: textToInsert },
+                };
+                await GDocsHelpers.executeBatchUpdate(docs, args.documentId, [request]);
+                log.info(`Successfully appended to doc: ${args.documentId}${args.tabId ? ` (tab: ${args.tabId})` : ''}`);
+                return `Successfully appended text to ${args.tabId ? `tab ${args.tabId} in ` : ''}document ${args.documentId}.`;
+            }
+            catch (error) {
+                log.error(`Error appending to doc ${args.documentId}: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                if (error instanceof NotImplementedError)
+                    throw error;
+                throw new UserError(`Failed to append to doc: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/docs/comments/addComment.js

@@ -0,0 +1,83 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { google } from 'googleapis';
+import { getDocsClient, getAuthClient } from '../../../clients.js';
+import { DocumentIdParameter } from '../../../types.js';
+export function register(server) {
+    server.addTool({
+        name: 'addComment',
+        description: 'Adds a comment to the document at the specified text range. Use listComments to retrieve the comment ID after creation. Note: programmatically created comments appear in the comments panel but may not show as anchored highlights in the document UI.',
+        parameters: DocumentIdParameter.extend({
+            startIndex: z
+                .number()
+                .int()
+                .min(1)
+                .describe('The starting index of the text range (inclusive, starts from 1).'),
+            endIndex: z.number().int().min(1).describe('The ending index of the text range (exclusive).'),
+            content: z.string().min(1).describe('The text content of the comment.'),
+        }).refine((data) => data.endIndex > data.startIndex, {
+            message: 'endIndex must be greater than startIndex',
+            path: ['endIndex'],
+        }),
+        execute: async (args, { log }) => {
+            log.info(`Adding comment to range ${args.startIndex}-${args.endIndex} in doc ${args.documentId}`);
+            try {
+                // First, get the text content that will be quoted
+                const docsClient = await getDocsClient();
+                const doc = await docsClient.documents.get({ documentId: args.documentId });
+                // Extract the quoted text from the document
+                let quotedText = '';
+                const content = doc.data.body?.content || [];
+                for (const element of content) {
+                    if (element.paragraph) {
+                        const elements = element.paragraph.elements || [];
+                        for (const textElement of elements) {
+                            if (textElement.textRun) {
+                                const elementStart = textElement.startIndex || 0;
+                                const elementEnd = textElement.endIndex || 0;
+                                // Check if this element overlaps with our range
+                                if (elementEnd > args.startIndex && elementStart < args.endIndex) {
+                                    const text = textElement.textRun.content || '';
+                                    const startOffset = Math.max(0, args.startIndex - elementStart);
+                                    const endOffset = Math.min(text.length, args.endIndex - elementStart);
+                                    quotedText += text.substring(startOffset, endOffset);
+                                }
+                            }
+                        }
+                    }
+                }
+                // Use Drive API v3 for comments
+                const authClient = await getAuthClient();
+                const drive = google.drive({ version: 'v3', auth: authClient });
+                const response = await drive.comments.create({
+                    fileId: args.documentId,
+                    fields: 'id,content,quotedFileContent,author,createdTime,resolved',
+                    requestBody: {
+                        content: args.content,
+                        quotedFileContent: {
+                            value: quotedText,
+                            mimeType: 'text/html',
+                        },
+                        anchor: JSON.stringify({
+                            r: args.documentId,
+                            a: [
+                                {
+                                    txt: {
+                                        o: args.startIndex - 1, // Drive API uses 0-based indexing
+                                        l: args.endIndex - args.startIndex,
+                                        ml: args.endIndex - args.startIndex,
+                                    },
+                                },
+                            ],
+                        }),
+                    },
+                });
+                return `Comment added successfully. Comment ID: ${response.data.id}`;
+            }
+            catch (error) {
+                log.error(`Error adding comment: ${error.message || error}`);
+                throw new UserError(`Failed to add comment: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/docs/comments/deleteComment.js

@@ -0,0 +1,30 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { google } from 'googleapis';
+import { getAuthClient } from '../../../clients.js';
+import { DocumentIdParameter } from '../../../types.js';
+export function register(server) {
+    server.addTool({
+        name: 'deleteComment',
+        description: 'Permanently deletes a comment and all its replies from the document.',
+        parameters: DocumentIdParameter.extend({
+            commentId: z.string().describe('The ID of the comment to delete'),
+        }),
+        execute: async (args, { log }) => {
+            log.info(`Deleting comment ${args.commentId} from doc ${args.documentId}`);
+            try {
+                const authClient = await getAuthClient();
+                const drive = google.drive({ version: 'v3', auth: authClient });
+                await drive.comments.delete({
+                    fileId: args.documentId,
+                    commentId: args.commentId,
+                });
+                return `Comment ${args.commentId} has been deleted.`;
+            }
+            catch (error) {
+                log.error(`Error deleting comment: ${error.message || error}`);
+                throw new UserError(`Failed to delete comment: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/docs/comments/getComment.js

@@ -0,0 +1,45 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { google } from 'googleapis';
+import { getAuthClient } from '../../../clients.js';
+import { DocumentIdParameter } from '../../../types.js';
+export function register(server) {
+    server.addTool({
+        name: 'getComment',
+        description: 'Gets a specific comment and its full reply thread. Use listComments first to find the comment ID.',
+        parameters: DocumentIdParameter.extend({
+            commentId: z.string().describe('The ID of the comment to retrieve'),
+        }),
+        execute: async (args, { log }) => {
+            log.info(`Getting comment ${args.commentId} from document ${args.documentId}`);
+            try {
+                const authClient = await getAuthClient();
+                const drive = google.drive({ version: 'v3', auth: authClient });
+                const response = await drive.comments.get({
+                    fileId: args.documentId,
+                    commentId: args.commentId,
+                    fields: 'id,content,quotedFileContent,author,createdTime,resolved,replies(id,content,author,createdTime)',
+                });
+                const comment = response.data;
+                return JSON.stringify({
+                    id: comment.id,
+                    author: comment.author?.displayName || null,
+                    content: comment.content,
+                    quotedText: comment.quotedFileContent?.value || null,
+                    resolved: comment.resolved || false,
+                    createdTime: comment.createdTime,
+                    replies: (comment.replies || []).map((r) => ({
+                        id: r.id,
+                        author: r.author?.displayName || null,
+                        content: r.content,
+                        createdTime: r.createdTime,
+                    })),
+                }, null, 2);
+            }
+            catch (error) {
+                log.error(`Error getting comment: ${error.message || error}`);
+                throw new UserError(`Failed to get comment: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/docs/comments/index.js

@@ -0,0 +1,14 @@
+import { register as listComments } from './listComments.js';
+import { register as getComment } from './getComment.js';
+import { register as addComment } from './addComment.js';
+import { register as replyToComment } from './replyToComment.js';
+import { register as resolveComment } from './resolveComment.js';
+import { register as deleteComment } from './deleteComment.js';
+export function registerCommentTools(server) {
+    listComments(server);
+    getComment(server);
+    addComment(server);
+    replyToComment(server);
+    resolveComment(server);
+    deleteComment(server);
+}

package/dist/tools/docs/comments/listComments.js

@@ -0,0 +1,43 @@
+import { UserError } from 'fastmcp';
+import { google } from 'googleapis';
+import { getDocsClient, getDriveClient, getAuthClient } from '../../../clients.js';
+import { DocumentIdParameter } from '../../../types.js';
+export function register(server) {
+    server.addTool({
+        name: 'listComments',
+        description: 'Lists all comments in a document with their IDs, authors, status, and quoted text. Returns data needed to call getComment, replyToComment, resolveComment, or deleteComment.',
+        parameters: DocumentIdParameter,
+        execute: async (args, { log }) => {
+            log.info(`Listing comments for document ${args.documentId}`);
+            const docsClient = await getDocsClient();
+            const driveClient = await getDriveClient();
+            try {
+                // First get the document to have context
+                const doc = await docsClient.documents.get({ documentId: args.documentId });
+                // Use Drive API v3 with proper fields to get quoted content
+                const authClient = await getAuthClient();
+                const drive = google.drive({ version: 'v3', auth: authClient });
+                const response = await drive.comments.list({
+                    fileId: args.documentId,
+                    fields: 'comments(id,content,quotedFileContent,author,createdTime,resolved)',
+                    pageSize: 100,
+                });
+                const comments = (response.data.comments || []).map((comment) => ({
+                    id: comment.id,
+                    author: comment.author?.displayName || null,
+                    content: comment.content,
+                    quotedText: comment.quotedFileContent?.value || null,
+                    resolved: comment.resolved || false,
+                    createdTime: comment.createdTime,
+                    modifiedTime: comment.modifiedTime,
+                    replyCount: comment.replies?.length || 0,
+                }));
+                return JSON.stringify({ comments }, null, 2);
+            }
+            catch (error) {
+                log.error(`Error listing comments: ${error.message || error}`);
+                throw new UserError(`Failed to list comments: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/docs/comments/replyToComment.js

@@ -0,0 +1,35 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { google } from 'googleapis';
+import { getAuthClient } from '../../../clients.js';
+import { DocumentIdParameter } from '../../../types.js';
+export function register(server) {
+    server.addTool({
+        name: 'replyToComment',
+        description: 'Adds a reply to an existing comment thread. Use listComments or getComment to find the comment ID.',
+        parameters: DocumentIdParameter.extend({
+            commentId: z.string().describe('The ID of the comment to reply to'),
+            content: z.string().min(1).describe('The text content of the reply.'),
+        }),
+        execute: async (args, { log }) => {
+            log.info(`Adding reply to comment ${args.commentId} in doc ${args.documentId}`);
+            try {
+                const authClient = await getAuthClient();
+                const drive = google.drive({ version: 'v3', auth: authClient });
+                const response = await drive.replies.create({
+                    fileId: args.documentId,
+                    commentId: args.commentId,
+                    fields: 'id,content,author,createdTime',
+                    requestBody: {
+                        content: args.content,
+                    },
+                });
+                return `Reply added successfully. Reply ID: ${response.data.id}`;
+            }
+            catch (error) {
+                log.error(`Error adding reply: ${error.message || error}`);
+                throw new UserError(`Failed to add reply: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/docs/comments/resolveComment.js

@@ -0,0 +1,55 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { google } from 'googleapis';
+import { getAuthClient } from '../../../clients.js';
+import { DocumentIdParameter } from '../../../types.js';
+export function register(server) {
+    server.addTool({
+        name: 'resolveComment',
+        description: 'Marks a comment as resolved. Note: resolved status may not persist in the Google Docs UI due to a Drive API limitation.',
+        parameters: DocumentIdParameter.extend({
+            commentId: z.string().describe('The ID of the comment to resolve'),
+        }),
+        execute: async (args, { log }) => {
+            log.info(`Resolving comment ${args.commentId} in doc ${args.documentId}`);
+            try {
+                const authClient = await getAuthClient();
+                const drive = google.drive({ version: 'v3', auth: authClient });
+                // First, get the current comment content (required by the API)
+                const currentComment = await drive.comments.get({
+                    fileId: args.documentId,
+                    commentId: args.commentId,
+                    fields: 'content',
+                });
+                // Update with both content and resolved status
+                await drive.comments.update({
+                    fileId: args.documentId,
+                    commentId: args.commentId,
+                    fields: 'id,resolved',
+                    requestBody: {
+                        content: currentComment.data.content,
+                        resolved: true,
+                    },
+                });
+                // Verify the resolved status was set
+                const verifyComment = await drive.comments.get({
+                    fileId: args.documentId,
+                    commentId: args.commentId,
+                    fields: 'resolved',
+                });
+                if (verifyComment.data.resolved) {
+                    return `Comment ${args.commentId} has been marked as resolved.`;
+                }
+                else {
+                    return `Attempted to resolve comment ${args.commentId}, but the resolved status may not persist in the Google Docs UI due to API limitations. The comment can be resolved manually in the Google Docs interface.`;
+                }
+            }
+            catch (error) {
+                log.error(`Error resolving comment: ${error.message || error}`);
+                const errorDetails = error.response?.data?.error?.message || error.message || 'Unknown error';
+                const errorCode = error.response?.data?.error?.code;
+                throw new UserError(`Failed to resolve comment: ${errorDetails}${errorCode ? ` (Code: ${errorCode})` : ''}`);
+            }
+        },
+    });
+}

package/dist/tools/docs/deleteRange.js

@@ -0,0 +1,72 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDocsClient } from '../../clients.js';
+import { DocumentIdParameter } from '../../types.js';
+import * as GDocsHelpers from '../../googleDocsApiHelpers.js';
+export function register(server) {
+    server.addTool({
+        name: 'deleteRange',
+        description: "Deletes content within a character range [startIndex, endIndex) from a document. Use readDocument with format='json' to determine index positions.",
+        parameters: DocumentIdParameter.extend({
+            startIndex: z
+                .number()
+                .int()
+                .min(1)
+                .describe('1-based character index within the document body. The start of the range to delete (inclusive).'),
+            endIndex: z
+                .number()
+                .int()
+                .min(1)
+                .describe('1-based character index within the document body. The end of the range to delete (exclusive).'),
+            tabId: z
+                .string()
+                .optional()
+                .describe('The ID of the specific tab to delete from. If not specified, deletes from the first tab (or legacy document.body for documents without tabs).'),
+        }).refine((data) => data.endIndex > data.startIndex, {
+            message: 'endIndex must be greater than startIndex',
+            path: ['endIndex'],
+        }),
+        execute: async (args, { log }) => {
+            const docs = await getDocsClient();
+            log.info(`Deleting range ${args.startIndex}-${args.endIndex} in doc ${args.documentId}${args.tabId ? ` (tab: ${args.tabId})` : ''}`);
+            if (args.endIndex <= args.startIndex) {
+                throw new UserError('End index must be greater than start index for deletion.');
+            }
+            try {
+                // If tabId is specified, verify the tab exists
+                if (args.tabId) {
+                    const docInfo = await docs.documents.get({
+                        documentId: args.documentId,
+                        includeTabsContent: true,
+                        fields: 'tabs(tabProperties,documentTab)',
+                    });
+                    const targetTab = GDocsHelpers.findTabById(docInfo.data, args.tabId);
+                    if (!targetTab) {
+                        throw new UserError(`Tab with ID "${args.tabId}" not found in document.`);
+                    }
+                    if (!targetTab.documentTab) {
+                        throw new UserError(`Tab "${args.tabId}" does not have content (may not be a document tab).`);
+                    }
+                }
+                const range = {
+                    startIndex: args.startIndex,
+                    endIndex: args.endIndex,
+                };
+                if (args.tabId) {
+                    range.tabId = args.tabId;
+                }
+                const request = {
+                    deleteContentRange: { range },
+                };
+                await GDocsHelpers.executeBatchUpdate(docs, args.documentId, [request]);
+                return `Successfully deleted content in range ${args.startIndex}-${args.endIndex}${args.tabId ? ` in tab ${args.tabId}` : ''}.`;
+            }
+            catch (error) {
+                log.error(`Error deleting range in doc ${args.documentId}: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to delete range: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/docs/findAndReplace.js

@@ -0,0 +1,54 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getDocsClient } from '../../clients.js';
+import { DocumentIdParameter } from '../../types.js';
+import * as GDocsHelpers from '../../googleDocsApiHelpers.js';
+const FindAndReplaceParameters = DocumentIdParameter.extend({
+    findText: z.string().min(1).describe('The text to search for in the document.'),
+    replaceText: z
+        .string()
+        .describe('The replacement text. Use an empty string to delete all occurrences.'),
+    matchCase: z
+        .boolean()
+        .optional()
+        .describe('Whether the search should be case-sensitive. Defaults to false.'),
+    tabId: z
+        .string()
+        .optional()
+        .describe('Scope replacement to a specific tab. If omitted, replaces across all tabs.'),
+});
+export function register(server) {
+    server.addTool({
+        name: 'findAndReplace',
+        description: 'Replaces all occurrences of a text string throughout the document (or a specific tab). ' +
+            'Returns the number of replacements made. Use an empty replaceText to delete all matches.',
+        parameters: FindAndReplaceParameters,
+        execute: async (args, { log }) => {
+            const docs = await getDocsClient();
+            log.info(`findAndReplace in doc ${args.documentId}: "${args.findText}" → "${args.replaceText}"` +
+                `${args.matchCase ? ' (case-sensitive)' : ''}` +
+                `${args.tabId ? ` (tab: ${args.tabId})` : ''}`);
+            try {
+                const request = {
+                    replaceAllText: {
+                        containsText: {
+                            text: args.findText,
+                            matchCase: args.matchCase ?? false,
+                        },
+                        replaceText: args.replaceText,
+                        ...(args.tabId && { tabsCriteria: { tabIds: [args.tabId] } }),
+                    },
+                };
+                const response = await GDocsHelpers.executeBatchUpdate(docs, args.documentId, [request]);
+                const changed = response.replies?.[0]?.replaceAllText?.occurrencesChanged ?? 0;
+                return `Replaced ${changed} occurrence(s) of "${args.findText}" with "${args.replaceText}".`;
+            }
+            catch (error) {
+                log.error(`Error in findAndReplace for doc ${args.documentId}: ${error.message || error}`);
+                if (error instanceof UserError)
+                    throw error;
+                throw new UserError(`Failed to find and replace: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}