google-workspace-mcp 2.1.1 → 2.3.4

package/dist/tools/gmail.tools.js

@@ -1,9 +1,15 @@
 // gmail.tools.ts - Gmail tool module
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
 import { z } from 'zod';
 import { formatToolError } from '../errorHelpers.js';
-import { getGmailMessageUrl, getGmailDraftsUrl } from '../urlHelpers.js';
+import { getGmailMessageUrl, getGmailDraftsUrl, getDriveFileUrl } from '../urlHelpers.js';
+import { Readable } from 'stream';
+import { validateWritePath, wrapEmailContent } from '../securityHelpers.js';
+import { getServerConfig } from '../serverWrapper.js';
 export function registerGmailTools(options) {
-    const { server, getGmailClient, getAccountEmail } = options;
+    const { server, getGmailClient, getDriveClient, getAccountEmail } = options;
     server.addTool({
         name: 'listGmailMessages',
         description: 'List email messages from Gmail inbox or other labels. Returns message IDs and snippets.',
@@ -79,6 +85,10 @@ export function registerGmailTools(options) {
                 .optional()
                 .default('full')
                 .describe('Response format'),
+            maxLength: z
+                .number()
+                .optional()
+                .describe('Maximum character length of the response. If the result exceeds this, it will be truncated with a notice.'),
         }),
         async execute(args, { log: _log }) {
             try {
@@ -154,7 +164,13 @@ export function registerGmailTools(options) {
                 if (message.snippet) {
                     result += `**Snippet:** ${message.snippet}\n\n`;
                 }
-                result += `**Body**\n${body || '(empty)'}\n\n`;
+                // Wrap email body with security warnings to defend against prompt injection
+                const from = getHeader('From');
+                const subject = getHeader('Subject');
+                const wrappedBody = body
+                    ? wrapEmailContent(body, from || undefined, subject || undefined)
+                    : '(empty)';
+                result += `**Body**\n${wrappedBody}\n\n`;
                 if (attachments.length > 0) {
                     result += `**Attachments (${attachments.length})**\n`;
                     attachments.forEach((att, i) => {
@@ -167,6 +183,11 @@ export function registerGmailTools(options) {
                 if (link) {
                     result += `View in Gmail: ${link}`;
                 }
+                // Apply maxLength truncation if specified
+                if (args.maxLength && result.length > args.maxLength) {
+                    result = result.substring(0, args.maxLength);
+                    result += `\n\n[...TRUNCATED at ${args.maxLength} chars. Full message has more content. Use a larger maxLength or omit it to see everything.]`;
+                }
                 return result;
             }
             catch (error) {
@@ -298,6 +319,78 @@ export function registerGmailTools(options) {
             }
         },
     });
+    // --- Create Gmail Label ---
+    server.addTool({
+        name: 'createGmailLabel',
+        description: 'Create a new Gmail label (folder). Labels can be used to organize emails. After creating a label, use addGmailLabel to apply it to messages.',
+        annotations: {
+            title: 'Create Gmail Label',
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        parameters: z.object({
+            account: z.string().describe('Account name to use'),
+            name: z
+                .string()
+                .describe('Name of the label to create. Use "/" for nested labels (e.g., "Work/Projects")'),
+            labelListVisibility: z
+                .enum(['labelShow', 'labelShowIfUnread', 'labelHide'])
+                .optional()
+                .default('labelShow')
+                .describe('Whether to show the label in the label list: labelShow (always), labelShowIfUnread (only when unread), labelHide (hidden)'),
+            messageListVisibility: z
+                .enum(['show', 'hide'])
+                .optional()
+                .default('show')
+                .describe('Whether to show the label in the message list'),
+            backgroundColor: z
+                .string()
+                .optional()
+                .describe('Background color in hex format (e.g., "#16a765")'),
+            textColor: z.string().optional().describe('Text color in hex format (e.g., "#ffffff")'),
+        }),
+        async execute(args, { log: _log }) {
+            try {
+                const gmail = await getGmailClient(args.account);
+                const labelColor = args.backgroundColor || args.textColor
+                    ? {
+                        backgroundColor: args.backgroundColor,
+                        textColor: args.textColor,
+                    }
+                    : undefined;
+                const response = await gmail.users.labels.create({
+                    userId: 'me',
+                    requestBody: {
+                        name: args.name,
+                        labelListVisibility: args.labelListVisibility,
+                        messageListVisibility: args.messageListVisibility,
+                        color: labelColor,
+                    },
+                });
+                const label = response.data;
+                let result = `Successfully created label "${args.name}".\n\n`;
+                result += `Label ID: ${label.id}\n`;
+                result += `Name: ${label.name}\n`;
+                result += `Type: ${label.type}\n`;
+                if (label.labelListVisibility) {
+                    result += `Label List Visibility: ${label.labelListVisibility}\n`;
+                }
+                if (label.messageListVisibility) {
+                    result += `Message List Visibility: ${label.messageListVisibility}\n`;
+                }
+                if (label.color) {
+                    result += `Color: ${label.color.backgroundColor || 'default'} / ${label.color.textColor || 'default'}\n`;
+                }
+                result += '\nUse this Label ID with addGmailLabel to apply it to messages.';
+                return result;
+            }
+            catch (error) {
+                throw new Error(formatToolError('createGmailLabel', error));
+            }
+        },
+    });
     // --- Add Gmail Label ---
     server.addTool({
         name: 'addGmailLabel',
@@ -463,26 +556,26 @@ export function registerGmailTools(options) {
                         emailContent += `In-Reply-To: ${inReplyTo}\r\n`;
                     if (references)
                         emailContent += `References: ${references}\r\n`;
-                    emailContent += `MIME-Version: 1.0\r\n`;
+                    emailContent += 'MIME-Version: 1.0\r\n';
                     emailContent += `Content-Type: multipart/mixed; boundary="${boundary}"\r\n`;
-                    emailContent += `\r\n`;
+                    emailContent += '\r\n';
                     // Body part
                     emailContent += `--${boundary}\r\n`;
                     emailContent += `Content-Type: ${args.isHtml ? 'text/html' : 'text/plain'}; charset=utf-8\r\n`;
-                    emailContent += `Content-Transfer-Encoding: 7bit\r\n`;
-                    emailContent += `\r\n`;
+                    emailContent += 'Content-Transfer-Encoding: 7bit\r\n';
+                    emailContent += '\r\n';
                     emailContent += `${args.body}\r\n`;
                     // Attachment parts
                     for (const attachment of args.attachments) {
                         emailContent += `--${boundary}\r\n`;
                         emailContent += `Content-Type: ${attachment.mimeType}; name="${attachment.filename}"\r\n`;
                         emailContent += `Content-Disposition: attachment; filename="${attachment.filename}"\r\n`;
-                        emailContent += `Content-Transfer-Encoding: base64\r\n`;
-                        emailContent += `\r\n`;
+                        emailContent += 'Content-Transfer-Encoding: base64\r\n';
+                        emailContent += '\r\n';
                         // Split base64 data into 76-character lines per RFC 2045
                         const base64Lines = attachment.base64Data.match(/.{1,76}/g) || [];
                         emailContent += base64Lines.join('\r\n');
-                        emailContent += `\r\n`;
+                        emailContent += '\r\n';
                     }
                     emailContent += `--${boundary}--\r\n`;
                 }
@@ -768,26 +861,26 @@ export function registerGmailTools(options) {
                     if (newBcc)
                         emailContent += `Bcc: ${newBcc}\r\n`;
                     emailContent += `Subject: ${newSubject}\r\n`;
-                    emailContent += `MIME-Version: 1.0\r\n`;
+                    emailContent += 'MIME-Version: 1.0\r\n';
                     emailContent += `Content-Type: multipart/mixed; boundary="${boundary}"\r\n`;
-                    emailContent += `\r\n`;
+                    emailContent += '\r\n';
                     // Body part
                     emailContent += `--${boundary}\r\n`;
                     emailContent += `Content-Type: ${isHtml ? 'text/html' : 'text/plain'}; charset=utf-8\r\n`;
-                    emailContent += `Content-Transfer-Encoding: 7bit\r\n`;
-                    emailContent += `\r\n`;
+                    emailContent += 'Content-Transfer-Encoding: 7bit\r\n';
+                    emailContent += '\r\n';
                     emailContent += `${newBody}\r\n`;
                     // Attachment parts
                     for (const attachment of args.attachments) {
                         emailContent += `--${boundary}\r\n`;
                         emailContent += `Content-Type: ${attachment.mimeType}; name="${attachment.filename}"\r\n`;
                         emailContent += `Content-Disposition: attachment; filename="${attachment.filename}"\r\n`;
-                        emailContent += `Content-Transfer-Encoding: base64\r\n`;
-                        emailContent += `\r\n`;
+                        emailContent += 'Content-Transfer-Encoding: base64\r\n';
+                        emailContent += '\r\n';
                         // Split base64 data into 76-character lines per RFC 2045
                         const base64Lines = attachment.base64Data.match(/.{1,76}/g) || [];
                         emailContent += base64Lines.join('\r\n');
-                        emailContent += `\r\n`;
+                        emailContent += '\r\n';
                     }
                     emailContent += `--${boundary}--\r\n`;
                 }
@@ -943,25 +1036,25 @@ export function registerGmailTools(options) {
                 if (getCurrentHeader('Bcc'))
                     emailContent += `Bcc: ${getCurrentHeader('Bcc')}\r\n`;
                 emailContent += `Subject: ${getCurrentHeader('Subject')}\r\n`;
-                emailContent += `MIME-Version: 1.0\r\n`;
+                emailContent += 'MIME-Version: 1.0\r\n';
                 emailContent += `Content-Type: multipart/mixed; boundary="${boundary}"\r\n`;
-                emailContent += `\r\n`;
+                emailContent += '\r\n';
                 // Body part
                 emailContent += `--${boundary}\r\n`;
                 emailContent += `Content-Type: ${bodyMimeType}; charset=utf-8\r\n`;
-                emailContent += `Content-Transfer-Encoding: 7bit\r\n`;
-                emailContent += `\r\n`;
+                emailContent += 'Content-Transfer-Encoding: 7bit\r\n';
+                emailContent += '\r\n';
                 emailContent += `${bodyContent}\r\n`;
                 // Attachment parts
                 for (const attachment of existingAttachments) {
                     emailContent += `--${boundary}\r\n`;
                     emailContent += `Content-Type: ${attachment.mimeType}; name="${attachment.filename}"\r\n`;
                     emailContent += `Content-Disposition: attachment; filename="${attachment.filename}"\r\n`;
-                    emailContent += `Content-Transfer-Encoding: base64\r\n`;
-                    emailContent += `\r\n`;
+                    emailContent += 'Content-Transfer-Encoding: base64\r\n';
+                    emailContent += '\r\n';
                     const base64Lines = attachment.data.match(/.{1,76}/g) || [];
                     emailContent += base64Lines.join('\r\n');
-                    emailContent += `\r\n`;
+                    emailContent += '\r\n';
                 }
                 emailContent += `--${boundary}--\r\n`;
                 const encodedEmail = Buffer.from(emailContent)
@@ -1088,25 +1181,25 @@ export function registerGmailTools(options) {
                     if (getCurrentHeader('Bcc'))
                         emailContent += `Bcc: ${getCurrentHeader('Bcc')}\r\n`;
                     emailContent += `Subject: ${getCurrentHeader('Subject')}\r\n`;
-                    emailContent += `MIME-Version: 1.0\r\n`;
+                    emailContent += 'MIME-Version: 1.0\r\n';
                     emailContent += `Content-Type: multipart/mixed; boundary="${boundary}"\r\n`;
-                    emailContent += `\r\n`;
+                    emailContent += '\r\n';
                     // Body part
                     emailContent += `--${boundary}\r\n`;
                     emailContent += `Content-Type: ${bodyMimeType}; charset=utf-8\r\n`;
-                    emailContent += `Content-Transfer-Encoding: 7bit\r\n`;
-                    emailContent += `\r\n`;
+                    emailContent += 'Content-Transfer-Encoding: 7bit\r\n';
+                    emailContent += '\r\n';
                     emailContent += `${bodyContent}\r\n`;
                     // Remaining attachment parts
                     for (const attachment of existingAttachments) {
                         emailContent += `--${boundary}\r\n`;
                         emailContent += `Content-Type: ${attachment.mimeType}; name="${attachment.filename}"\r\n`;
                         emailContent += `Content-Disposition: attachment; filename="${attachment.filename}"\r\n`;
-                        emailContent += `Content-Transfer-Encoding: base64\r\n`;
-                        emailContent += `\r\n`;
+                        emailContent += 'Content-Transfer-Encoding: base64\r\n';
+                        emailContent += '\r\n';
                         const base64Lines = attachment.data.match(/.{1,76}/g) || [];
                         emailContent += base64Lines.join('\r\n');
-                        emailContent += `\r\n`;
+                        emailContent += '\r\n';
                     }
                     emailContent += `--${boundary}--\r\n`;
                 }
@@ -1256,7 +1349,7 @@ export function registerGmailTools(options) {
     // --- Get Gmail Attachment ---
     server.addTool({
         name: 'getGmailAttachment',
-        description: 'Download an attachment from a Gmail message. Returns the attachment as base64-encoded data along with metadata.',
+        description: 'Get metadata and a preview of a Gmail attachment. Returns truncated base64 data (first 500 chars). For full attachment data or saving to file, use downloadGmailAttachment instead.',
         annotations: {
             title: 'Get Gmail Attachment',
             readOnlyHint: true,
@@ -1287,7 +1380,10 @@ export function registerGmailTools(options) {
                     // The data is already base64url encoded from Gmail API
                     result += `**Base64 Data (first 500 chars):**\n${attachment.data.substring(0, 500)}${attachment.data.length > 500 ? '...' : ''}\n\n`;
                     result += `**Full data length:** ${attachment.data.length} characters\n`;
-                    result += `\nNote: Data is base64url encoded. To decode, replace - with + and _ with /, then base64 decode.`;
+                    result +=
+                        '\nNote: Data is base64url encoded. To decode, replace - with + and _ with /, then base64 decode.';
+                    result +=
+                        '\n\nTip: Use downloadGmailAttachment to get full data or save directly to a file.';
                 }
                 else {
                     result += 'No attachment data available.';
@@ -1299,6 +1395,234 @@ export function registerGmailTools(options) {
             }
         },
     });
+    // --- Download Gmail Attachment ---
+    server.addTool({
+        name: 'downloadGmailAttachment',
+        description: 'Download a Gmail attachment with full data. Returns complete base64-encoded data, or saves directly to a file if savePath is provided. Use this instead of getGmailAttachment when you need the full attachment content.',
+        annotations: {
+            title: 'Download Gmail Attachment',
+            readOnlyHint: true,
+            openWorldHint: true,
+        },
+        parameters: z.object({
+            account: z.string().describe('Account name to use'),
+            messageId: z.string().describe('The ID of the message containing the attachment'),
+            attachmentId: z
+                .string()
+                .describe('The attachment ID (from readGmailMessage attachment info)'),
+            savePath: z
+                .string()
+                .optional()
+                .describe('Optional file path to save the attachment to. If provided, the decoded attachment is written to this path. The path must be absolute.'),
+        }),
+        async execute(args, { log: _log }) {
+            try {
+                const gmail = await getGmailClient(args.account);
+                // First, get attachment metadata from the message to find the filename
+                const messageResponse = await gmail.users.messages.get({
+                    userId: 'me',
+                    id: args.messageId,
+                    format: 'full',
+                });
+                // Find attachment info in message parts
+                let attachmentFilename = 'attachment';
+                let attachmentMimeType = 'application/octet-stream';
+                const findAttachmentInfo = (part) => {
+                    if (part.body?.attachmentId === args.attachmentId && part.filename) {
+                        attachmentFilename = part.filename;
+                        attachmentMimeType = part.mimeType || 'application/octet-stream';
+                        return true;
+                    }
+                    if (part.parts) {
+                        for (const subpart of part.parts) {
+                            if (findAttachmentInfo(subpart))
+                                return true;
+                        }
+                    }
+                    return false;
+                };
+                if (messageResponse.data.payload) {
+                    findAttachmentInfo(messageResponse.data.payload);
+                }
+                // Get the attachment data
+                const response = await gmail.users.messages.attachments.get({
+                    userId: 'me',
+                    messageId: args.messageId,
+                    id: args.attachmentId,
+                });
+                const attachment = response.data;
+                const size = attachment.size || 0;
+                if (!attachment.data) {
+                    throw new Error('No attachment data available');
+                }
+                // Convert base64url to standard base64
+                const base64Data = attachment.data.replace(/-/g, '+').replace(/_/g, '/');
+                let result = '**Attachment Downloaded**\n\n';
+                result += `Filename: ${attachmentFilename}\n`;
+                result += `MIME Type: ${attachmentMimeType}\n`;
+                result += `Size: ${size} bytes (${(size / 1024).toFixed(2)} KB)\n`;
+                result += `Message ID: ${args.messageId}\n`;
+                result += `Attachment ID: ${args.attachmentId}\n\n`;
+                if (args.savePath) {
+                    // Validate that savePath is absolute
+                    if (!path.isAbsolute(args.savePath)) {
+                        throw new Error(`savePath must be an absolute path. Received: ${args.savePath}`);
+                    }
+                    // Validate path for security
+                    const pathValidation = validateWritePath(args.savePath, getServerConfig().pathSecurity);
+                    if (!pathValidation.valid) {
+                        throw new Error(`Cannot save to this path: ${pathValidation.error}`);
+                    }
+                    // Decode and save to file
+                    const buffer = Buffer.from(base64Data, 'base64');
+                    // Ensure parent directory exists
+                    const parentDir = path.dirname(pathValidation.resolvedPath);
+                    await fs.mkdir(parentDir, { recursive: true });
+                    await fs.writeFile(pathValidation.resolvedPath, buffer);
+                    result += `**Saved to:** ${pathValidation.resolvedPath}\n`;
+                    result += `File size on disk: ${buffer.length} bytes`;
+                }
+                else {
+                    // Auto-save large attachments to temp file to avoid blowing up LLM context
+                    const MAX_INLINE_BYTES = 1024; // 1KB threshold
+                    const buffer = Buffer.from(base64Data, 'base64');
+                    if (buffer.length > MAX_INLINE_BYTES) {
+                        const tempDir = os.tmpdir();
+                        const safeName = attachmentFilename.replace(/[^a-zA-Z0-9._-]/g, '_');
+                        const tempPath = path.join(tempDir, `gmail-attachment-${Date.now()}-${safeName}`);
+                        await fs.writeFile(tempPath, buffer);
+                        result += `**Saved to:** ${tempPath}\n`;
+                        result += `File size on disk: ${buffer.length} bytes\n\n`;
+                        result += `⚠️ File was auto-saved to a temp path because it exceeds the ${MAX_INLINE_BYTES}-byte inline limit.\n`;
+                        result += `Use the savePath parameter to save to a specific location.`;
+                    }
+                    else {
+                        // Small enough to return inline
+                        result += `**Base64 Data (standard encoding):**\n${base64Data}`;
+                    }
+                }
+                return result;
+            }
+            catch (error) {
+                throw new Error(formatToolError('downloadGmailAttachment', error));
+            }
+        },
+    });
+    // --- Save Gmail Attachment to Drive ---
+    server.addTool({
+        name: 'saveAttachmentToDrive',
+        description: 'Save a Gmail attachment directly to Google Drive. Uploads the attachment as a file to Drive without downloading locally first.',
+        annotations: {
+            title: 'Save Attachment to Drive',
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        parameters: z.object({
+            account: z.string().describe('Account name to use'),
+            messageId: z.string().describe('The ID of the message containing the attachment'),
+            attachmentId: z
+                .string()
+                .describe('The attachment ID (from readGmailMessage attachment info)'),
+            fileName: z
+                .string()
+                .optional()
+                .describe('Optional custom file name for the saved file. If not provided, uses the original attachment name.'),
+            folderId: z
+                .string()
+                .optional()
+                .describe('Optional Google Drive folder ID to save the file to. If not provided, saves to root of My Drive.'),
+        }),
+        async execute(args, { log: _log }) {
+            try {
+                const gmail = await getGmailClient(args.account);
+                const drive = await getDriveClient(args.account);
+                const accountEmail = await getAccountEmail(args.account);
+                // First, get attachment metadata from the message to find the filename
+                const messageResponse = await gmail.users.messages.get({
+                    userId: 'me',
+                    id: args.messageId,
+                    format: 'full',
+                });
+                // Find attachment info in message parts
+                let attachmentFilename = 'attachment';
+                let attachmentMimeType = 'application/octet-stream';
+                const findAttachmentInfo = (part) => {
+                    if (part.body?.attachmentId === args.attachmentId && part.filename) {
+                        attachmentFilename = part.filename;
+                        attachmentMimeType = part.mimeType || 'application/octet-stream';
+                        return true;
+                    }
+                    if (part.parts) {
+                        for (const subpart of part.parts) {
+                            if (findAttachmentInfo(subpart))
+                                return true;
+                        }
+                    }
+                    return false;
+                };
+                if (messageResponse.data.payload) {
+                    findAttachmentInfo(messageResponse.data.payload);
+                }
+                // Use custom filename if provided
+                const finalFileName = args.fileName || attachmentFilename;
+                // Get the attachment data
+                const attachmentResponse = await gmail.users.messages.attachments.get({
+                    userId: 'me',
+                    messageId: args.messageId,
+                    id: args.attachmentId,
+                });
+                const attachment = attachmentResponse.data;
+                const size = attachment.size || 0;
+                if (!attachment.data) {
+                    throw new Error('No attachment data available');
+                }
+                // Convert base64url to standard base64, then to buffer
+                const base64Data = attachment.data.replace(/-/g, '+').replace(/_/g, '/');
+                const buffer = Buffer.from(base64Data, 'base64');
+                // Create a readable stream from the buffer for Drive upload
+                const bufferStream = new Readable();
+                bufferStream.push(buffer);
+                bufferStream.push(null);
+                // Upload to Google Drive
+                const fileMetadata = {
+                    name: finalFileName,
+                };
+                if (args.folderId) {
+                    fileMetadata.parents = [args.folderId];
+                }
+                const driveResponse = await drive.files.create({
+                    requestBody: fileMetadata,
+                    media: {
+                        mimeType: attachmentMimeType,
+                        body: bufferStream,
+                    },
+                    fields: 'id,name,webViewLink,mimeType,size',
+                });
+                const driveFile = driveResponse.data;
+                const fileId = driveFile.id;
+                if (!fileId) {
+                    throw new Error('Failed to upload file to Drive - no file ID returned');
+                }
+                const driveLink = getDriveFileUrl(fileId, accountEmail);
+                let result = '**Attachment Saved to Drive**\n\n';
+                result += `File Name: ${driveFile.name}\n`;
+                result += `File ID: ${fileId}\n`;
+                result += `MIME Type: ${driveFile.mimeType || attachmentMimeType}\n`;
+                result += `Size: ${size} bytes (${(size / 1024).toFixed(2)} KB)\n`;
+                if (args.folderId) {
+                    result += `Folder ID: ${args.folderId}\n`;
+                }
+                result += `\nView in Drive: ${driveLink}\n`;
+                result += `\nSource Message ID: ${args.messageId}`;
+                return result;
+            }
+            catch (error) {
+                throw new Error(formatToolError('saveAttachmentToDrive', error));
+            }
+        },
+    });
     // --- Mark as Read ---
     server.addTool({
         name: 'markAsRead',
@@ -1458,6 +1782,10 @@ export function registerGmailTools(options) {
                 .optional()
                 .default('full')
                 .describe('Response format for messages in the thread'),
+            maxLength: z
+                .number()
+                .optional()
+                .describe('Maximum character length of the response. If the result exceeds this, it will be truncated with a notice.'),
         }),
         async execute(args, { log: _log }) {
             try {
@@ -1494,7 +1822,7 @@ export function registerGmailTools(options) {
                     }
                     return '';
                 };
-                let result = `**Email Thread**\n\n`;
+                let result = '**Email Thread**\n\n';
                 result += `Thread ID: ${thread.id}\n`;
                 result += `Messages in thread: ${messages.length}\n`;
                 result += `History ID: ${thread.historyId}\n\n`;
@@ -1513,7 +1841,13 @@ export function registerGmailTools(options) {
                     result += `Labels: ${(message.labelIds ?? []).join(', ') || 'None'}\n\n`;
                     if (args.format === 'full' && message.payload) {
                         const body = extractBody(message.payload);
-                        result += `**Body:**\n${body || '(empty)'}\n`;
+                        // Wrap email body with security warnings to defend against prompt injection
+                        const from = getHeader(headers, 'From');
+                        const subject = getHeader(headers, 'Subject');
+                        const wrappedBody = body
+                            ? wrapEmailContent(body, from || undefined, subject || undefined)
+                            : '(empty)';
+                        result += `**Body:**\n${wrappedBody}\n`;
                     }
                     else if (message.snippet) {
                         result += `**Snippet:** ${message.snippet}\n`;
@@ -1526,6 +1860,11 @@ export function registerGmailTools(options) {
                 if (link) {
                     result += `\n\nView thread in Gmail: ${link}`;
                 }
+                // Apply maxLength truncation if specified
+                if (args.maxLength && result.length > args.maxLength) {
+                    result = result.substring(0, args.maxLength);
+                    result += `\n\n[...TRUNCATED at ${args.maxLength} chars. Thread has ${messages.length} messages. Use a larger maxLength or omit it to see everything.]`;
+                }
                 return result;
             }
             catch (error) {
@@ -1664,7 +2003,7 @@ export function registerGmailTools(options) {
                     if (criteria.query)
                         result += `     - Query: ${criteria.query}\n`;
                     if (criteria.hasAttachment)
-                        result += `     - Has attachment: yes\n`;
+                        result += '     - Has attachment: yes\n';
                     if (criteria.size)
                         result += `     - Size: ${criteria.sizeComparison} ${criteria.size} bytes\n`;
                     result += '   Actions:\n';
@@ -1758,7 +2097,7 @@ export function registerGmailTools(options) {
                 if (args.query)
                     result += `- Query: ${args.query}\n`;
                 if (args.hasAttachment)
-                    result += `- Has attachment: yes\n`;
+                    result += '- Has attachment: yes\n';
                 result += '\n**Actions:**\n';
                 if (args.addLabelIds?.length)
                     result += `- Add labels: ${args.addLabelIds.join(', ')}\n`;