google-tools-mcp 1.0.0 → 1.0.1

package/dist/tools/gmail/messages.js

@@ -1,448 +1,448 @@
-// Gmail Message tools
-import { z } from 'zod';
-import { getGmailClient } from '../../clients.js';
-import { processMessagePart, constructRawMessage, constructRawMessageWithAttachments, findHeader, formatEmailList, getNestedHistory, getPlainTextBody, wrapTextBody } from '../../helpers.js';
-
-export function register(server) {
-    server.addTool({
-        name: 'send_message',
-        description: 'Send an email message to specified recipients. Note the mechanics of the raw parameter.',
-        parameters: z.object({
-            raw: z.string().optional().describe("The entire email message in base64url encoded RFC 2822 format, ignores to, cc, bcc, subject, body if provided"),
-            threadId: z.string().optional().describe("The thread ID to associate this message with"),
-            to: z.array(z.string()).optional().describe("List of recipient email addresses"),
-            cc: z.array(z.string()).optional().describe("List of CC recipient email addresses"),
-            bcc: z.array(z.string()).optional().describe("List of BCC recipient email addresses"),
-            subject: z.string().optional().describe("The subject of the email"),
-            body: z.string().optional().describe("The body of the email"),
-            attachments: z.array(z.object({
-                filename: z.string().describe("Attachment file name"),
-                mimeType: z.string().describe("MIME type of the attachment"),
-                base64Data: z.string().describe("Base64 encoded attachment data"),
-            })).optional().describe("File attachments to include"),
-            includeBodyHtml: z.boolean().optional().describe("Whether to include the parsed HTML in the return for each body"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            let raw = params.raw;
-            if (!raw) {
-                if (params.attachments?.length) {
-                    raw = await constructRawMessageWithAttachments(gmail, params);
-                } else {
-                    raw = await constructRawMessage(gmail, params);
-                }
-            }
-            const sendParams = { userId: 'me', requestBody: { raw } };
-            if (params.threadId && sendParams.requestBody) {
-                sendParams.requestBody.threadId = params.threadId;
-            }
-            const { data } = await gmail.users.messages.send(sendParams);
-            if (data.payload) {
-                data.payload = processMessagePart(data.payload, params.includeBodyHtml);
-            }
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'reply_message',
-        description: 'Reply to a message. Automatically handles To/Cc recipients, subject prefix, threading headers, and quoted content. Use replyAll to include all original recipients.',
-        parameters: z.object({
-            messageId: z.string().describe("The ID of the message to reply to"),
-            body: z.string().describe("The reply body text"),
-            replyAll: z.boolean().optional().describe("If true, reply to all original recipients (To + Cc minus yourself). Default: false"),
-            to: z.array(z.string()).optional().describe("Override recipient list (if omitted, replies to sender or Reply-To)"),
-            cc: z.array(z.string()).optional().describe("Override CC list (if omitted and replyAll, uses original To + Cc minus yourself)"),
-            bcc: z.array(z.string()).optional().describe("Optional BCC recipients"),
-            attachments: z.array(z.object({
-                filename: z.string().describe("Attachment file name"),
-                mimeType: z.string().describe("MIME type of the attachment"),
-                base64Data: z.string().describe("Base64 encoded attachment data"),
-            })).optional().describe("Optional attachments to include in the reply"),
-            includeBodyHtml: z.boolean().optional().describe("Whether to include the parsed HTML in the return"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            // Fetch original message
-            const { data: original } = await gmail.users.messages.get({ userId: 'me', id: params.messageId, format: 'full' });
-            const headers = original.payload?.headers || [];
-            const threadId = original.threadId;
-            // Get sender info for quoted content
-            const fromHeader = findHeader(headers, 'reply-to') || findHeader(headers, 'from');
-            const dateHeader = findHeader(headers, 'date');
-            const originalSubject = findHeader(headers, 'subject') || '';
-            const messageIdHeader = findHeader(headers, 'message-id');
-            const referencesHeader = findHeader(headers, 'references');
-            // Build subject
-            let subject = originalSubject;
-            if (!subject.toLowerCase().startsWith('re:')) {
-                subject = `Re: ${subject}`;
-            }
-            // Build recipients
-            let to = params.to;
-            let cc = params.cc;
-            if (!to) {
-                to = fromHeader ? [fromHeader] : [];
-            }
-            if (!cc && params.replyAll) {
-                // Get own email for exclusion
-                const { data: profile } = await gmail.users.getProfile({ userId: 'me' });
-                const myEmail = profile.emailAddress?.toLowerCase();
-                const originalTo = formatEmailList(findHeader(headers, 'to'));
-                const originalCc = formatEmailList(findHeader(headers, 'cc'));
-                const allRecipients = [...originalTo, ...originalCc].filter(
-                    email => !email.toLowerCase().includes(myEmail)
-                );
-                // Remove the sender from CC since they're in To
-                cc = allRecipients.filter(email => !to.some(t => email.toLowerCase().includes(t.toLowerCase())));
-            }
-            // Build threading headers
-            const references = [];
-            if (referencesHeader) references.push(...referencesHeader.split(' '));
-            if (messageIdHeader) references.push(messageIdHeader);
-            // Build quoted content from the original message
-            let quotedContent = '';
-            if (original.payload) {
-                const originalBody = getNestedHistory(original.payload);
-                if (originalBody && fromHeader && dateHeader) {
-                    quotedContent = `\n\nOn ${dateHeader} ${fromHeader} wrote:\n\n${originalBody}`;
-                }
-            }
-            const fullBody = params.body + quotedContent;
-            // Build raw message
-            const msgHeaders = [];
-            if (to?.length) msgHeaders.push(`To: ${to.join(', ')}`);
-            if (cc?.length) msgHeaders.push(`Cc: ${cc.join(', ')}`);
-            if (params.bcc?.length) msgHeaders.push(`Bcc: ${params.bcc.join(', ')}`);
-            msgHeaders.push(`Subject: ${subject}`);
-            if (messageIdHeader) msgHeaders.push(`In-Reply-To: ${messageIdHeader}`);
-            if (references.length) msgHeaders.push(`References: ${references.join(' ')}`);
-            let raw;
-            if (params.attachments?.length) {
-                const boundary = `boundary_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-                msgHeaders.push('MIME-Version: 1.0');
-                msgHeaders.push(`Content-Type: multipart/mixed; boundary="${boundary}"`);
-                const parts = [];
-                parts.push([
-                    `--${boundary}`,
-                    'Content-Type: text/plain; charset="UTF-8"',
-                    'Content-Transfer-Encoding: base64',
-                    '',
-                    Buffer.from(fullBody).toString('base64'),
-                ].join('\r\n'));
-                for (const att of params.attachments) {
-                    parts.push([
-                        `--${boundary}`,
-                        `Content-Type: ${att.mimeType}; name="${att.filename}"`,
-                        'Content-Transfer-Encoding: base64',
-                        `Content-Disposition: attachment; filename="${att.filename}"`,
-                        '',
-                        att.base64Data,
-                    ].join('\r\n'));
-                }
-                const rawStr = [msgHeaders.join('\r\n'), '', parts.join('\r\n'), `--${boundary}--`].join('\r\n');
-                raw = Buffer.from(rawStr).toString('base64url').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-            } else {
-                msgHeaders.push('Content-Type: text/plain; charset="UTF-8"');
-                msgHeaders.push('Content-Transfer-Encoding: quoted-printable');
-                msgHeaders.push('MIME-Version: 1.0');
-                const rawStr = [msgHeaders.join('\r\n'), '', wrapTextBody(fullBody)].join('\r\n');
-                raw = Buffer.from(rawStr).toString('base64url').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-            }
-            const { data } = await gmail.users.messages.send({
-                userId: 'me',
-                requestBody: { raw, threadId },
-            });
-            if (data.payload) {
-                data.payload = processMessagePart(data.payload, params.includeBodyHtml);
-            }
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'forward_message',
-        description: 'Forward a message to new recipients. Includes the original message body as quoted content and re-attaches any original attachments.',
-        parameters: z.object({
-            messageId: z.string().describe("The ID of the message to forward"),
-            to: z.array(z.string()).describe("Recipient email addresses to forward to"),
-            cc: z.array(z.string()).optional().describe("CC recipient email addresses"),
-            bcc: z.array(z.string()).optional().describe("BCC recipient email addresses"),
-            body: z.string().optional().describe("Optional commentary to prepend above the forwarded content"),
-            includeAttachments: z.boolean().optional().describe("Whether to include original attachments. Default: true"),
-            includeBodyHtml: z.boolean().optional().describe("Whether to include the parsed HTML in the return"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            // Fetch original message
-            const { data: original } = await gmail.users.messages.get({ userId: 'me', id: params.messageId, format: 'full' });
-            const headers = original.payload?.headers || [];
-            const originalSubject = findHeader(headers, 'subject') || '';
-            const fromHeader = findHeader(headers, 'from') || '';
-            const dateHeader = findHeader(headers, 'date') || '';
-            const toHeader = findHeader(headers, 'to') || '';
-            // Build subject
-            let subject = originalSubject;
-            if (!subject.toLowerCase().startsWith('fwd:')) {
-                subject = `Fwd: ${subject}`;
-            }
-            // Build forwarded content
-            const originalBody = original.payload ? getPlainTextBody(original.payload) : '';
-            let forwardedContent = [
-                '---------- Forwarded message ---------',
-                `From: ${fromHeader}`,
-                `Date: ${dateHeader}`,
-                `Subject: ${originalSubject}`,
-                `To: ${toHeader}`,
-                '',
-                originalBody,
-            ].join('\n');
-            const fullBody = (params.body ? params.body + '\n\n' : '') + forwardedContent;
-            // Collect original attachments
-            const attachments = [];
-            const includeAttachments = params.includeAttachments !== false;
-            if (includeAttachments && original.payload) {
-                const collectAttachments = (part) => {
-                    if (part.filename && part.body?.attachmentId) {
-                        attachments.push({
-                            filename: part.filename,
-                            mimeType: part.mimeType || 'application/octet-stream',
-                            attachmentId: part.body.attachmentId,
-                        });
-                    }
-                    if (part.parts) part.parts.forEach(collectAttachments);
-                };
-                collectAttachments(original.payload);
-            }
-            // Fetch attachment data
-            const attachmentParts = [];
-            for (const att of attachments) {
-                const { data: attData } = await gmail.users.messages.attachments.get({
-                    userId: 'me', messageId: params.messageId, id: att.attachmentId,
-                });
-                attachmentParts.push({
-                    filename: att.filename,
-                    mimeType: att.mimeType,
-                    base64Data: attData.data.replace(/-/g, '+').replace(/_/g, '/'),
-                });
-            }
-            // Build raw message
-            const msgHeaders = [];
-            msgHeaders.push(`To: ${params.to.join(', ')}`);
-            if (params.cc?.length) msgHeaders.push(`Cc: ${params.cc.join(', ')}`);
-            if (params.bcc?.length) msgHeaders.push(`Bcc: ${params.bcc.join(', ')}`);
-            msgHeaders.push(`Subject: ${subject}`);
-            let raw;
-            if (attachmentParts.length) {
-                const boundary = `boundary_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-                msgHeaders.push('MIME-Version: 1.0');
-                msgHeaders.push(`Content-Type: multipart/mixed; boundary="${boundary}"`);
-                const parts = [];
-                parts.push([
-                    `--${boundary}`,
-                    'Content-Type: text/plain; charset="UTF-8"',
-                    'Content-Transfer-Encoding: base64',
-                    '',
-                    Buffer.from(fullBody).toString('base64'),
-                ].join('\r\n'));
-                for (const att of attachmentParts) {
-                    parts.push([
-                        `--${boundary}`,
-                        `Content-Type: ${att.mimeType}; name="${att.filename}"`,
-                        'Content-Transfer-Encoding: base64',
-                        `Content-Disposition: attachment; filename="${att.filename}"`,
-                        '',
-                        att.base64Data,
-                    ].join('\r\n'));
-                }
-                const rawStr = [msgHeaders.join('\r\n'), '', parts.join('\r\n'), `--${boundary}--`].join('\r\n');
-                raw = Buffer.from(rawStr).toString('base64url').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-            } else {
-                msgHeaders.push('Content-Type: text/plain; charset="UTF-8"');
-                msgHeaders.push('Content-Transfer-Encoding: quoted-printable');
-                msgHeaders.push('MIME-Version: 1.0');
-                const rawStr = [msgHeaders.join('\r\n'), '', wrapTextBody(fullBody)].join('\r\n');
-                raw = Buffer.from(rawStr).toString('base64url').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-            }
-            const { data } = await gmail.users.messages.send({
-                userId: 'me',
-                requestBody: { raw },
-            });
-            if (data.payload) {
-                data.payload = processMessagePart(data.payload, params.includeBodyHtml);
-            }
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'get_message',
-        description: 'Get a specific message by ID with format options',
-        parameters: z.object({
-            id: z.string().describe("The ID of the message to retrieve"),
-            includeBodyHtml: z.boolean().optional().describe("Whether to include the parsed HTML in the return for each body"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.messages.get({ userId: 'me', id: params.id, format: 'full' });
-            if (data.payload) {
-                data.payload = processMessagePart(data.payload, params.includeBodyHtml);
-            }
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'list_messages',
-        description: 'List messages in the user\'s mailbox with optional filtering',
-        parameters: z.object({
-            maxResults: z.number().optional().describe("Maximum number of messages to return (1-500)"),
-            pageToken: z.string().optional().describe("Page token to retrieve a specific page of results"),
-            q: z.string().optional().describe("Only return messages matching the specified query (same format as Gmail search box)"),
-            labelIds: z.array(z.string()).optional().describe("Only return messages with labels that match all specified label IDs"),
-            includeSpamTrash: z.boolean().optional().describe("Include messages from SPAM and TRASH"),
-            includeBodyHtml: z.boolean().optional().describe("Whether to include the parsed HTML in the return for each body"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.messages.list({ userId: 'me', ...params });
-            if (data.messages) {
-                data.messages = data.messages.map(message => {
-                    if (message.payload) {
-                        message.payload = processMessagePart(message.payload, params.includeBodyHtml);
-                    }
-                    return message;
-                });
-            }
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'modify_message',
-        description: 'Modify the labels on a message',
-        parameters: z.object({
-            id: z.string().describe("The ID of the message to modify"),
-            addLabelIds: z.array(z.string()).optional().describe("Label IDs to add"),
-            removeLabelIds: z.array(z.string()).optional().describe("Label IDs to remove"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.messages.modify({
-                userId: 'me', id: params.id,
-                requestBody: { addLabelIds: params.addLabelIds, removeLabelIds: params.removeLabelIds }
-            });
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'delete_message',
-        description: 'Immediately and permanently delete a message',
-        parameters: z.object({
-            id: z.string().describe("The ID of the message to delete"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.messages.delete({ userId: 'me', id: params.id });
-            return JSON.stringify(data || { success: true });
-        },
-    });
-
-    server.addTool({
-        name: 'trash_message',
-        description: 'Move a message to the trash',
-        parameters: z.object({
-            id: z.string().describe("The ID of the message to move to trash"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.messages.trash({ userId: 'me', id: params.id });
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'untrash_message',
-        description: 'Remove a message from the trash',
-        parameters: z.object({
-            id: z.string().describe("The ID of the message to remove from trash"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.messages.untrash({ userId: 'me', id: params.id });
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'batch_delete_messages',
-        description: 'Delete multiple messages',
-        parameters: z.object({
-            ids: z.array(z.string()).describe("The IDs of the messages to delete"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.messages.batchDelete({ userId: 'me', requestBody: { ids: params.ids } });
-            return JSON.stringify(data || { success: true });
-        },
-    });
-
-    server.addTool({
-        name: 'batch_modify_messages',
-        description: 'Modify the labels on multiple messages',
-        parameters: z.object({
-            ids: z.array(z.string()).describe("The IDs of the messages to modify"),
-            addLabelIds: z.array(z.string()).optional().describe("Label IDs to add"),
-            removeLabelIds: z.array(z.string()).optional().describe("Label IDs to remove"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.messages.batchModify({
-                userId: 'me',
-                requestBody: { ids: params.ids, addLabelIds: params.addLabelIds, removeLabelIds: params.removeLabelIds }
-            });
-            return JSON.stringify(data || { success: true });
-        },
-    });
-
-    server.addTool({
-        name: 'batch_get_messages',
-        description: 'Get multiple messages by ID in parallel. More efficient than calling get_message multiple times.',
-        parameters: z.object({
-            ids: z.array(z.string()).describe("The IDs of the messages to retrieve"),
-            includeBodyHtml: z.boolean().optional().describe("Whether to include the parsed HTML in the return for each body"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const results = await Promise.all(
-                params.ids.map(async (id) => {
-                    try {
-                        const { data } = await gmail.users.messages.get({ userId: 'me', id, format: 'full' });
-                        if (data.payload) {
-                            data.payload = processMessagePart(data.payload, params.includeBodyHtml);
-                        }
-                        return data;
-                    } catch (error) {
-                        return { id, error: error.message || 'Failed to retrieve message' };
-                    }
-                })
-            );
-            return JSON.stringify(results);
-        },
-    });
-
-    server.addTool({
-        name: 'get_attachment',
-        description: 'Get a message attachment',
-        parameters: z.object({
-            messageId: z.string().describe("ID of the message containing the attachment"),
-            id: z.string().describe("The ID of the attachment"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.messages.attachments.get({ userId: 'me', messageId: params.messageId, id: params.id });
-            return JSON.stringify(data);
-        },
-    });
-}
+// Gmail Message tools
+import { z } from 'zod';
+import { getGmailClient } from '../../clients.js';
+import { processMessagePart, constructRawMessage, constructRawMessageWithAttachments, findHeader, formatEmailList, getNestedHistory, getPlainTextBody, wrapTextBody } from '../../helpers.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'send_message',
+        description: 'Send an email message to specified recipients. Note the mechanics of the raw parameter.',
+        parameters: z.object({
+            raw: z.string().optional().describe("The entire email message in base64url encoded RFC 2822 format, ignores to, cc, bcc, subject, body if provided"),
+            threadId: z.string().optional().describe("The thread ID to associate this message with"),
+            to: z.array(z.string()).optional().describe("List of recipient email addresses"),
+            cc: z.array(z.string()).optional().describe("List of CC recipient email addresses"),
+            bcc: z.array(z.string()).optional().describe("List of BCC recipient email addresses"),
+            subject: z.string().optional().describe("The subject of the email"),
+            body: z.string().optional().describe("The body of the email"),
+            attachments: z.array(z.object({
+                filename: z.string().describe("Attachment file name"),
+                mimeType: z.string().describe("MIME type of the attachment"),
+                base64Data: z.string().describe("Base64 encoded attachment data"),
+            })).optional().describe("File attachments to include"),
+            includeBodyHtml: z.boolean().optional().describe("Whether to include the parsed HTML in the return for each body"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            let raw = params.raw;
+            if (!raw) {
+                if (params.attachments?.length) {
+                    raw = await constructRawMessageWithAttachments(gmail, params);
+                } else {
+                    raw = await constructRawMessage(gmail, params);
+                }
+            }
+            const sendParams = { userId: 'me', requestBody: { raw } };
+            if (params.threadId && sendParams.requestBody) {
+                sendParams.requestBody.threadId = params.threadId;
+            }
+            const { data } = await gmail.users.messages.send(sendParams);
+            if (data.payload) {
+                data.payload = processMessagePart(data.payload, params.includeBodyHtml);
+            }
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'reply_message',
+        description: 'Reply to a message. Automatically handles To/Cc recipients, subject prefix, threading headers, and quoted content. Use replyAll to include all original recipients.',
+        parameters: z.object({
+            messageId: z.string().describe("The ID of the message to reply to"),
+            body: z.string().describe("The reply body text"),
+            replyAll: z.boolean().optional().describe("If true, reply to all original recipients (To + Cc minus yourself). Default: false"),
+            to: z.array(z.string()).optional().describe("Override recipient list (if omitted, replies to sender or Reply-To)"),
+            cc: z.array(z.string()).optional().describe("Override CC list (if omitted and replyAll, uses original To + Cc minus yourself)"),
+            bcc: z.array(z.string()).optional().describe("Optional BCC recipients"),
+            attachments: z.array(z.object({
+                filename: z.string().describe("Attachment file name"),
+                mimeType: z.string().describe("MIME type of the attachment"),
+                base64Data: z.string().describe("Base64 encoded attachment data"),
+            })).optional().describe("Optional attachments to include in the reply"),
+            includeBodyHtml: z.boolean().optional().describe("Whether to include the parsed HTML in the return"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            // Fetch original message
+            const { data: original } = await gmail.users.messages.get({ userId: 'me', id: params.messageId, format: 'full' });
+            const headers = original.payload?.headers || [];
+            const threadId = original.threadId;
+            // Get sender info for quoted content
+            const fromHeader = findHeader(headers, 'reply-to') || findHeader(headers, 'from');
+            const dateHeader = findHeader(headers, 'date');
+            const originalSubject = findHeader(headers, 'subject') || '';
+            const messageIdHeader = findHeader(headers, 'message-id');
+            const referencesHeader = findHeader(headers, 'references');
+            // Build subject
+            let subject = originalSubject;
+            if (!subject.toLowerCase().startsWith('re:')) {
+                subject = `Re: ${subject}`;
+            }
+            // Build recipients
+            let to = params.to;
+            let cc = params.cc;
+            if (!to) {
+                to = fromHeader ? [fromHeader] : [];
+            }
+            if (!cc && params.replyAll) {
+                // Get own email for exclusion
+                const { data: profile } = await gmail.users.getProfile({ userId: 'me' });
+                const myEmail = profile.emailAddress?.toLowerCase();
+                const originalTo = formatEmailList(findHeader(headers, 'to'));
+                const originalCc = formatEmailList(findHeader(headers, 'cc'));
+                const allRecipients = [...originalTo, ...originalCc].filter(
+                    email => !email.toLowerCase().includes(myEmail)
+                );
+                // Remove the sender from CC since they're in To
+                cc = allRecipients.filter(email => !to.some(t => email.toLowerCase().includes(t.toLowerCase())));
+            }
+            // Build threading headers
+            const references = [];
+            if (referencesHeader) references.push(...referencesHeader.split(' '));
+            if (messageIdHeader) references.push(messageIdHeader);
+            // Build quoted content from the original message
+            let quotedContent = '';
+            if (original.payload) {
+                const originalBody = getNestedHistory(original.payload);
+                if (originalBody && fromHeader && dateHeader) {
+                    quotedContent = `\n\nOn ${dateHeader} ${fromHeader} wrote:\n\n${originalBody}`;
+                }
+            }
+            const fullBody = params.body + quotedContent;
+            // Build raw message
+            const msgHeaders = [];
+            if (to?.length) msgHeaders.push(`To: ${to.join(', ')}`);
+            if (cc?.length) msgHeaders.push(`Cc: ${cc.join(', ')}`);
+            if (params.bcc?.length) msgHeaders.push(`Bcc: ${params.bcc.join(', ')}`);
+            msgHeaders.push(`Subject: ${subject}`);
+            if (messageIdHeader) msgHeaders.push(`In-Reply-To: ${messageIdHeader}`);
+            if (references.length) msgHeaders.push(`References: ${references.join(' ')}`);
+            let raw;
+            if (params.attachments?.length) {
+                const boundary = `boundary_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+                msgHeaders.push('MIME-Version: 1.0');
+                msgHeaders.push(`Content-Type: multipart/mixed; boundary="${boundary}"`);
+                const parts = [];
+                parts.push([
+                    `--${boundary}`,
+                    'Content-Type: text/plain; charset="UTF-8"',
+                    'Content-Transfer-Encoding: base64',
+                    '',
+                    Buffer.from(fullBody).toString('base64'),
+                ].join('\r\n'));
+                for (const att of params.attachments) {
+                    parts.push([
+                        `--${boundary}`,
+                        `Content-Type: ${att.mimeType}; name="${att.filename}"`,
+                        'Content-Transfer-Encoding: base64',
+                        `Content-Disposition: attachment; filename="${att.filename}"`,
+                        '',
+                        att.base64Data,
+                    ].join('\r\n'));
+                }
+                const rawStr = [msgHeaders.join('\r\n'), '', parts.join('\r\n'), `--${boundary}--`].join('\r\n');
+                raw = Buffer.from(rawStr).toString('base64url').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+            } else {
+                msgHeaders.push('Content-Type: text/plain; charset="UTF-8"');
+                msgHeaders.push('Content-Transfer-Encoding: quoted-printable');
+                msgHeaders.push('MIME-Version: 1.0');
+                const rawStr = [msgHeaders.join('\r\n'), '', wrapTextBody(fullBody)].join('\r\n');
+                raw = Buffer.from(rawStr).toString('base64url').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+            }
+            const { data } = await gmail.users.messages.send({
+                userId: 'me',
+                requestBody: { raw, threadId },
+            });
+            if (data.payload) {
+                data.payload = processMessagePart(data.payload, params.includeBodyHtml);
+            }
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'forward_message',
+        description: 'Forward a message to new recipients. Includes the original message body as quoted content and re-attaches any original attachments.',
+        parameters: z.object({
+            messageId: z.string().describe("The ID of the message to forward"),
+            to: z.array(z.string()).describe("Recipient email addresses to forward to"),
+            cc: z.array(z.string()).optional().describe("CC recipient email addresses"),
+            bcc: z.array(z.string()).optional().describe("BCC recipient email addresses"),
+            body: z.string().optional().describe("Optional commentary to prepend above the forwarded content"),
+            includeAttachments: z.boolean().optional().describe("Whether to include original attachments. Default: true"),
+            includeBodyHtml: z.boolean().optional().describe("Whether to include the parsed HTML in the return"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            // Fetch original message
+            const { data: original } = await gmail.users.messages.get({ userId: 'me', id: params.messageId, format: 'full' });
+            const headers = original.payload?.headers || [];
+            const originalSubject = findHeader(headers, 'subject') || '';
+            const fromHeader = findHeader(headers, 'from') || '';
+            const dateHeader = findHeader(headers, 'date') || '';
+            const toHeader = findHeader(headers, 'to') || '';
+            // Build subject
+            let subject = originalSubject;
+            if (!subject.toLowerCase().startsWith('fwd:')) {
+                subject = `Fwd: ${subject}`;
+            }
+            // Build forwarded content
+            const originalBody = original.payload ? getPlainTextBody(original.payload) : '';
+            let forwardedContent = [
+                '---------- Forwarded message ---------',
+                `From: ${fromHeader}`,
+                `Date: ${dateHeader}`,
+                `Subject: ${originalSubject}`,
+                `To: ${toHeader}`,
+                '',
+                originalBody,
+            ].join('\n');
+            const fullBody = (params.body ? params.body + '\n\n' : '') + forwardedContent;
+            // Collect original attachments
+            const attachments = [];
+            const includeAttachments = params.includeAttachments !== false;
+            if (includeAttachments && original.payload) {
+                const collectAttachments = (part) => {
+                    if (part.filename && part.body?.attachmentId) {
+                        attachments.push({
+                            filename: part.filename,
+                            mimeType: part.mimeType || 'application/octet-stream',
+                            attachmentId: part.body.attachmentId,
+                        });
+                    }
+                    if (part.parts) part.parts.forEach(collectAttachments);
+                };
+                collectAttachments(original.payload);
+            }
+            // Fetch attachment data
+            const attachmentParts = [];
+            for (const att of attachments) {
+                const { data: attData } = await gmail.users.messages.attachments.get({
+                    userId: 'me', messageId: params.messageId, id: att.attachmentId,
+                });
+                attachmentParts.push({
+                    filename: att.filename,
+                    mimeType: att.mimeType,
+                    base64Data: attData.data.replace(/-/g, '+').replace(/_/g, '/'),
+                });
+            }
+            // Build raw message
+            const msgHeaders = [];
+            msgHeaders.push(`To: ${params.to.join(', ')}`);
+            if (params.cc?.length) msgHeaders.push(`Cc: ${params.cc.join(', ')}`);
+            if (params.bcc?.length) msgHeaders.push(`Bcc: ${params.bcc.join(', ')}`);
+            msgHeaders.push(`Subject: ${subject}`);
+            let raw;
+            if (attachmentParts.length) {
+                const boundary = `boundary_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+                msgHeaders.push('MIME-Version: 1.0');
+                msgHeaders.push(`Content-Type: multipart/mixed; boundary="${boundary}"`);
+                const parts = [];
+                parts.push([
+                    `--${boundary}`,
+                    'Content-Type: text/plain; charset="UTF-8"',
+                    'Content-Transfer-Encoding: base64',
+                    '',
+                    Buffer.from(fullBody).toString('base64'),
+                ].join('\r\n'));
+                for (const att of attachmentParts) {
+                    parts.push([
+                        `--${boundary}`,
+                        `Content-Type: ${att.mimeType}; name="${att.filename}"`,
+                        'Content-Transfer-Encoding: base64',
+                        `Content-Disposition: attachment; filename="${att.filename}"`,
+                        '',
+                        att.base64Data,
+                    ].join('\r\n'));
+                }
+                const rawStr = [msgHeaders.join('\r\n'), '', parts.join('\r\n'), `--${boundary}--`].join('\r\n');
+                raw = Buffer.from(rawStr).toString('base64url').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+            } else {
+                msgHeaders.push('Content-Type: text/plain; charset="UTF-8"');
+                msgHeaders.push('Content-Transfer-Encoding: quoted-printable');
+                msgHeaders.push('MIME-Version: 1.0');
+                const rawStr = [msgHeaders.join('\r\n'), '', wrapTextBody(fullBody)].join('\r\n');
+                raw = Buffer.from(rawStr).toString('base64url').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+            }
+            const { data } = await gmail.users.messages.send({
+                userId: 'me',
+                requestBody: { raw },
+            });
+            if (data.payload) {
+                data.payload = processMessagePart(data.payload, params.includeBodyHtml);
+            }
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'get_message',
+        description: 'Get a specific message by ID with format options',
+        parameters: z.object({
+            id: z.string().describe("The ID of the message to retrieve"),
+            includeBodyHtml: z.boolean().optional().describe("Whether to include the parsed HTML in the return for each body"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.messages.get({ userId: 'me', id: params.id, format: 'full' });
+            if (data.payload) {
+                data.payload = processMessagePart(data.payload, params.includeBodyHtml);
+            }
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'list_messages',
+        description: 'List messages in the user\'s mailbox with optional filtering',
+        parameters: z.object({
+            maxResults: z.number().optional().describe("Maximum number of messages to return (1-500)"),
+            pageToken: z.string().optional().describe("Page token to retrieve a specific page of results"),
+            q: z.string().optional().describe("Only return messages matching the specified query (same format as Gmail search box)"),
+            labelIds: z.array(z.string()).optional().describe("Only return messages with labels that match all specified label IDs"),
+            includeSpamTrash: z.boolean().optional().describe("Include messages from SPAM and TRASH"),
+            includeBodyHtml: z.boolean().optional().describe("Whether to include the parsed HTML in the return for each body"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.messages.list({ userId: 'me', ...params });
+            if (data.messages) {
+                data.messages = data.messages.map(message => {
+                    if (message.payload) {
+                        message.payload = processMessagePart(message.payload, params.includeBodyHtml);
+                    }
+                    return message;
+                });
+            }
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'modify_message',
+        description: 'Modify the labels on a message',
+        parameters: z.object({
+            id: z.string().describe("The ID of the message to modify"),
+            addLabelIds: z.array(z.string()).optional().describe("Label IDs to add"),
+            removeLabelIds: z.array(z.string()).optional().describe("Label IDs to remove"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.messages.modify({
+                userId: 'me', id: params.id,
+                requestBody: { addLabelIds: params.addLabelIds, removeLabelIds: params.removeLabelIds }
+            });
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'delete_message',
+        description: 'Immediately and permanently delete a message',
+        parameters: z.object({
+            id: z.string().describe("The ID of the message to delete"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.messages.delete({ userId: 'me', id: params.id });
+            return JSON.stringify(data || { success: true });
+        },
+    });
+
+    server.addTool({
+        name: 'trash_message',
+        description: 'Move a message to the trash',
+        parameters: z.object({
+            id: z.string().describe("The ID of the message to move to trash"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.messages.trash({ userId: 'me', id: params.id });
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'untrash_message',
+        description: 'Remove a message from the trash',
+        parameters: z.object({
+            id: z.string().describe("The ID of the message to remove from trash"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.messages.untrash({ userId: 'me', id: params.id });
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'batch_delete_messages',
+        description: 'Delete multiple messages',
+        parameters: z.object({
+            ids: z.array(z.string()).describe("The IDs of the messages to delete"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.messages.batchDelete({ userId: 'me', requestBody: { ids: params.ids } });
+            return JSON.stringify(data || { success: true });
+        },
+    });
+
+    server.addTool({
+        name: 'batch_modify_messages',
+        description: 'Modify the labels on multiple messages',
+        parameters: z.object({
+            ids: z.array(z.string()).describe("The IDs of the messages to modify"),
+            addLabelIds: z.array(z.string()).optional().describe("Label IDs to add"),
+            removeLabelIds: z.array(z.string()).optional().describe("Label IDs to remove"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.messages.batchModify({
+                userId: 'me',
+                requestBody: { ids: params.ids, addLabelIds: params.addLabelIds, removeLabelIds: params.removeLabelIds }
+            });
+            return JSON.stringify(data || { success: true });
+        },
+    });
+
+    server.addTool({
+        name: 'batch_get_messages',
+        description: 'Get multiple messages by ID in parallel. More efficient than calling get_message multiple times.',
+        parameters: z.object({
+            ids: z.array(z.string()).describe("The IDs of the messages to retrieve"),
+            includeBodyHtml: z.boolean().optional().describe("Whether to include the parsed HTML in the return for each body"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const results = await Promise.all(
+                params.ids.map(async (id) => {
+                    try {
+                        const { data } = await gmail.users.messages.get({ userId: 'me', id, format: 'full' });
+                        if (data.payload) {
+                            data.payload = processMessagePart(data.payload, params.includeBodyHtml);
+                        }
+                        return data;
+                    } catch (error) {
+                        return { id, error: error.message || 'Failed to retrieve message' };
+                    }
+                })
+            );
+            return JSON.stringify(results);
+        },
+    });
+
+    server.addTool({
+        name: 'get_attachment',
+        description: 'Get a message attachment',
+        parameters: z.object({
+            messageId: z.string().describe("ID of the message containing the attachment"),
+            id: z.string().describe("The ID of the attachment"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.messages.attachments.get({ userId: 'me', messageId: params.messageId, id: params.id });
+            return JSON.stringify(data);
+        },
+    });
+}