google-tools-mcp 1.2.12 → 2.0.0

package/dist/tools/gmail/drafts.js

@@ -1,165 +1,165 @@
-// Gmail Draft tools
-import { z } from 'zod';
-import { UserError } from 'fastmcp';
-import { getGmailClient } from '../../clients.js';
-import { processMessagePart, constructRawMessage, constructRawMessageWithAttachments } from '../../helpers.js';
-
-export function register(server) {
-    server.addTool({
-        name: 'create_draft',
-        description: 'Create a draft email in Gmail. 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 params.to, cc, bcc, subject, body, includeBodyHtml if provided"),
-            threadId: z.string().optional().describe("The thread ID to associate this draft 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. Supports plain text or HTML (auto-detected). Use HTML tags like <p>, <br>, <b> for formatted emails."),
-            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, { log }) => {
-            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 createParams = { userId: 'me', requestBody: { message: { raw } } };
-            if (params.threadId && createParams.requestBody?.message) {
-                createParams.requestBody.message.threadId = params.threadId;
-            }
-            const { data } = await gmail.users.drafts.create(createParams);
-            if (data.message?.payload) {
-                data.message.payload = processMessagePart(data.message.payload, params.includeBodyHtml);
-            }
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'update_draft',
-        description: 'Update an existing draft\'s content. Replaces the draft message with new content.',
-        parameters: z.object({
-            id: z.string().describe("The ID of the draft to update"),
-            raw: z.string().optional().describe("The entire email message in base64url encoded RFC 2822 format, ignores other params if provided"),
-            threadId: z.string().optional().describe("The thread ID to associate this draft 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. Supports plain text or HTML (auto-detected). Use HTML tags like <p>, <br>, <b> for formatted emails."),
-            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 updateParams = { userId: 'me', id: params.id, requestBody: { message: { raw } } };
-            if (params.threadId && updateParams.requestBody?.message) {
-                updateParams.requestBody.message.threadId = params.threadId;
-            }
-            const { data } = await gmail.users.drafts.update(updateParams);
-            if (data.message?.payload) {
-                data.message.payload = processMessagePart(data.message.payload, params.includeBodyHtml);
-            }
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'delete_draft',
-        description: 'Delete a draft',
-        parameters: z.object({
-            id: z.string().describe("The ID of the draft to delete"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.drafts.delete({ userId: 'me', id: params.id });
-            return JSON.stringify(data || { success: true });
-        },
-    });
-
-    server.addTool({
-        name: 'get_draft',
-        description: 'Get a specific draft by ID',
-        parameters: z.object({
-            id: z.string().describe("The ID of the draft 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.drafts.get({ userId: 'me', id: params.id, format: 'full' });
-            if (data.message?.payload) {
-                data.message.payload = processMessagePart(data.message.payload, params.includeBodyHtml);
-            }
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'list_drafts',
-        description: 'List drafts in the user\'s mailbox',
-        parameters: z.object({
-            maxResults: z.number().optional().describe("Maximum number of drafts to return (1-500)"),
-            q: z.string().optional().describe("Only return drafts matching the specified query"),
-            includeSpamTrash: z.boolean().optional().describe("Include drafts 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();
-            let drafts = [];
-            const { data } = await gmail.users.drafts.list({ userId: 'me', ...params });
-            drafts.push(...(data.drafts || []));
-            let pageToken = data.nextPageToken;
-            while (pageToken) {
-                const { data: nextData } = await gmail.users.drafts.list({ userId: 'me', ...params, pageToken });
-                drafts.push(...(nextData.drafts || []));
-                pageToken = nextData.nextPageToken;
-            }
-            drafts = drafts.map(draft => {
-                if (draft.message?.payload) {
-                    draft.message.payload = processMessagePart(draft.message.payload, params.includeBodyHtml);
-                }
-                return draft;
-            });
-            return JSON.stringify(drafts);
-        },
-    });
-
-    server.addTool({
-        name: 'send_draft',
-        description: 'Send an existing draft',
-        parameters: z.object({
-            id: z.string().describe("The ID of the draft to send"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            try {
-                const { data } = await gmail.users.drafts.send({ userId: 'me', requestBody: { id: params.id } });
-                return JSON.stringify(data);
-            } catch (error) {
-                throw new UserError('Error sending draft, are you sure you have at least one recipient?');
-            }
-        },
-    });
-}
+// Gmail Draft tools
+import { z } from 'zod';
+import { UserError } from 'fastmcp';
+import { getGmailClient } from '../../clients.js';
+import { processMessagePart, constructRawMessage, constructRawMessageWithAttachments } from '../../helpers.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'createDraft',
+        description: 'Create a draft email in Gmail. 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 params.to, cc, bcc, subject, body, includeBodyHtml if provided"),
+            threadId: z.string().optional().describe("The thread ID to associate this draft 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. Supports plain text or HTML (auto-detected). Use HTML tags like <p>, <br>, <b> for formatted emails."),
+            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, { log }) => {
+            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 createParams = { userId: 'me', requestBody: { message: { raw } } };
+            if (params.threadId && createParams.requestBody?.message) {
+                createParams.requestBody.message.threadId = params.threadId;
+            }
+            const { data } = await gmail.users.drafts.create(createParams);
+            if (data.message?.payload) {
+                data.message.payload = processMessagePart(data.message.payload, params.includeBodyHtml);
+            }
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'updateDraft',
+        description: 'Update an existing draft\'s content. Replaces the draft message with new content.',
+        parameters: z.object({
+            id: z.string().describe("The ID of the draft to update"),
+            raw: z.string().optional().describe("The entire email message in base64url encoded RFC 2822 format, ignores other params if provided"),
+            threadId: z.string().optional().describe("The thread ID to associate this draft 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. Supports plain text or HTML (auto-detected). Use HTML tags like <p>, <br>, <b> for formatted emails."),
+            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 updateParams = { userId: 'me', id: params.id, requestBody: { message: { raw } } };
+            if (params.threadId && updateParams.requestBody?.message) {
+                updateParams.requestBody.message.threadId = params.threadId;
+            }
+            const { data } = await gmail.users.drafts.update(updateParams);
+            if (data.message?.payload) {
+                data.message.payload = processMessagePart(data.message.payload, params.includeBodyHtml);
+            }
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'deleteDraft',
+        description: 'Delete a draft',
+        parameters: z.object({
+            id: z.string().describe("The ID of the draft to delete"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.drafts.delete({ userId: 'me', id: params.id });
+            return JSON.stringify(data || { success: true });
+        },
+    });
+
+    server.addTool({
+        name: 'getDraft',
+        description: 'Get a specific draft by ID',
+        parameters: z.object({
+            id: z.string().describe("The ID of the draft 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.drafts.get({ userId: 'me', id: params.id, format: 'full' });
+            if (data.message?.payload) {
+                data.message.payload = processMessagePart(data.message.payload, params.includeBodyHtml);
+            }
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'listDrafts',
+        description: 'List drafts in the user\'s mailbox',
+        parameters: z.object({
+            maxResults: z.number().optional().describe("Maximum number of drafts to return (1-500)"),
+            q: z.string().optional().describe("Only return drafts matching the specified query"),
+            includeSpamTrash: z.boolean().optional().describe("Include drafts 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();
+            let drafts = [];
+            const { data } = await gmail.users.drafts.list({ userId: 'me', ...params });
+            drafts.push(...(data.drafts || []));
+            let pageToken = data.nextPageToken;
+            while (pageToken) {
+                const { data: nextData } = await gmail.users.drafts.list({ userId: 'me', ...params, pageToken });
+                drafts.push(...(nextData.drafts || []));
+                pageToken = nextData.nextPageToken;
+            }
+            drafts = drafts.map(draft => {
+                if (draft.message?.payload) {
+                    draft.message.payload = processMessagePart(draft.message.payload, params.includeBodyHtml);
+                }
+                return draft;
+            });
+            return JSON.stringify(drafts);
+        },
+    });
+
+    server.addTool({
+        name: 'sendDraft',
+        description: 'Send an existing draft',
+        parameters: z.object({
+            id: z.string().describe("The ID of the draft to send"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            try {
+                const { data } = await gmail.users.drafts.send({ userId: 'me', requestBody: { id: params.id } });
+                return JSON.stringify(data);
+            } catch (error) {
+                throw new UserError('Error sending draft, are you sure you have at least one recipient?');
+            }
+        },
+    });
+}

package/dist/tools/gmail/labels.js

@@ -1,83 +1,54 @@
-// Gmail Label tools
-import { z } from 'zod';
-import { getGmailClient } from '../../clients.js';
-
-export function register(server) {
-    server.addTool({
-        name: 'create_label',
-        description: 'Create a new label',
-        parameters: z.object({
-            name: z.string().describe("The display name of the label"),
-            messageListVisibility: z.enum(['show', 'hide']).optional().describe("Visibility of messages with this label in the message list"),
-            labelListVisibility: z.enum(['labelShow', 'labelShowIfUnread', 'labelHide']).optional().describe("Visibility of the label in the label list"),
-            color: z.object({
-                textColor: z.string().describe("The text color as hex string"),
-                backgroundColor: z.string().describe("The background color as hex string"),
-            }).optional().describe("The color settings for the label"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.labels.create({ userId: 'me', requestBody: params });
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'delete_label',
-        description: 'Delete a label',
-        parameters: z.object({
-            id: z.string().describe("The ID of the label to delete"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.labels.delete({ userId: 'me', id: params.id });
-            return JSON.stringify(data || { success: true });
-        },
-    });
-
-    server.addTool({
-        name: 'get_label',
-        description: 'Get a specific label by ID',
-        parameters: z.object({
-            id: z.string().describe("The ID of the label to retrieve"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.labels.get({ userId: 'me', id: params.id });
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'list_labels',
-        description: 'List all labels in the user\'s mailbox',
-        parameters: z.object({}),
-        execute: async () => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.labels.list({ userId: 'me' });
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'patch_label',
-        description: 'Patch an existing label (partial update)',
-        parameters: z.object({
-            id: z.string().describe("The ID of the label to patch"),
-            name: z.string().optional().describe("The display name of the label"),
-            messageListVisibility: z.enum(['show', 'hide']).optional().describe("Visibility of messages with this label"),
-            labelListVisibility: z.enum(['labelShow', 'labelShowIfUnread', 'labelHide']).optional().describe("Visibility of the label in the label list"),
-            color: z.object({
-                textColor: z.string().describe("The text color as hex string"),
-                backgroundColor: z.string().describe("The background color as hex string"),
-            }).optional().describe("The color settings for the label"),
-        }),
-        execute: async (params) => {
-            const { id, ...labelData } = params;
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.labels.patch({ userId: 'me', id, requestBody: labelData });
-            return JSON.stringify(data);
-        },
-    });
-
-}
+// Gmail Label tools — consolidated dispatch tool (issue #31/#32/#33).
+// manageLabel replaces create/patch/delete/get/list_label(s).
+import { z } from 'zod';
+import { UserError } from 'fastmcp';
+import { getGmailClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'manageLabel',
+        description:
+            'Manage Gmail labels. action: create | patch | delete | get | list. ' +
+            'create requires name. patch/delete/get require id.',
+        parameters: z.object({
+            action: z.enum(['create', 'patch', 'delete', 'get', 'list']).describe('The label operation to perform'),
+            id: z.string().optional().describe('The label ID (required for patch, delete, get)'),
+            name: z.string().optional().describe('The display name of the label (required for create)'),
+            messageListVisibility: z.enum(['show', 'hide']).optional().describe('Visibility of messages with this label in the message list'),
+            labelListVisibility: z.enum(['labelShow', 'labelShowIfUnread', 'labelHide']).optional().describe('Visibility of the label in the label list'),
+            color: z.object({
+                textColor: z.string().describe('The text color as hex string'),
+                backgroundColor: z.string().describe('The background color as hex string'),
+            }).optional().describe('The color settings for the label'),
+        }),
+        execute: async (params) => {
+            if (params.action === 'create' && !params.name) {
+                throw new UserError('manageLabel action="create" requires name.');
+            }
+            if (['patch', 'delete', 'get'].includes(params.action) && !params.id) {
+                throw new UserError(`manageLabel action="${params.action}" requires id.`);
+            }
+            const gmail = await getGmailClient();
+            const { action, id, ...labelData } = params;
+            let data;
+            switch (action) {
+                case 'create':
+                    ({ data } = await gmail.users.labels.create({ userId: 'me', requestBody: labelData }));
+                    break;
+                case 'patch':
+                    ({ data } = await gmail.users.labels.patch({ userId: 'me', id, requestBody: labelData }));
+                    break;
+                case 'delete':
+                    ({ data } = await gmail.users.labels.delete({ userId: 'me', id }));
+                    break;
+                case 'get':
+                    ({ data } = await gmail.users.labels.get({ userId: 'me', id }));
+                    break;
+                case 'list':
+                    ({ data } = await gmail.users.labels.list({ userId: 'me' }));
+                    break;
+            }
+            return JSON.stringify(data || { success: true });
+        },
+    });
+}