google-tools-mcp 1.0.0 → 1.0.1

package/dist/tools/gmail/threads.js

@@ -1,145 +1,145 @@
-// Gmail Thread tools
-import { z } from 'zod';
-import { getGmailClient } from '../../clients.js';
-import { processMessagePart } from '../../helpers.js';
-
-export function register(server) {
-    server.addTool({
-        name: 'get_thread',
-        description: 'Get a specific thread by ID',
-        parameters: z.object({
-            id: z.string().describe("The ID of the thread 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.threads.get({ userId: 'me', id: params.id, format: 'full' });
-            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: 'list_threads',
-        description: 'List threads in the user\'s mailbox',
-        parameters: z.object({
-            maxResults: z.number().optional().describe("Maximum number of threads to return"),
-            pageToken: z.string().optional().describe("Page token to retrieve a specific page of results"),
-            q: z.string().optional().describe("Only return threads matching the specified query"),
-            labelIds: z.array(z.string()).optional().describe("Only return threads with labels that match all specified label IDs"),
-            includeSpamTrash: z.boolean().optional().describe("Include threads 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.threads.list({ userId: 'me', ...params });
-            if (data.threads) {
-                data.threads = data.threads.map(thread => {
-                    if (thread.messages) {
-                        thread.messages = thread.messages.map(message => {
-                            if (message.payload) {
-                                message.payload = processMessagePart(message.payload, params.includeBodyHtml);
-                            }
-                            return message;
-                        });
-                    }
-                    return thread;
-                });
-            }
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'batch_get_threads',
-        description: 'Get multiple threads by ID in parallel. More efficient than calling get_thread multiple times.',
-        parameters: z.object({
-            ids: z.array(z.string()).describe("The IDs of the threads 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.threads.get({ userId: 'me', id, format: 'full' });
-                        if (data.messages) {
-                            data.messages = data.messages.map(message => {
-                                if (message.payload) {
-                                    message.payload = processMessagePart(message.payload, params.includeBodyHtml);
-                                }
-                                return message;
-                            });
-                        }
-                        return data;
-                    } catch (error) {
-                        return { id, error: error.message || 'Failed to retrieve thread' };
-                    }
-                })
-            );
-            return JSON.stringify(results);
-        },
-    });
-
-    server.addTool({
-        name: 'modify_thread',
-        description: 'Modify the labels applied to a thread',
-        parameters: z.object({
-            id: z.string().describe("The ID of the thread 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 { id, ...threadData } = params;
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.threads.modify({ userId: 'me', id, requestBody: threadData });
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'delete_thread',
-        description: 'Delete a thread',
-        parameters: z.object({
-            id: z.string().describe("The ID of the thread to delete"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.threads.delete({ userId: 'me', id: params.id });
-            return JSON.stringify(data || { success: true });
-        },
-    });
-
-    server.addTool({
-        name: 'trash_thread',
-        description: 'Move a thread to the trash',
-        parameters: z.object({
-            id: z.string().describe("The ID of the thread to move to trash"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.threads.trash({ userId: 'me', id: params.id });
-            return JSON.stringify(data);
-        },
-    });
-
-    server.addTool({
-        name: 'untrash_thread',
-        description: 'Remove a thread from the trash',
-        parameters: z.object({
-            id: z.string().describe("The ID of the thread to remove from trash"),
-        }),
-        execute: async (params) => {
-            const gmail = await getGmailClient();
-            const { data } = await gmail.users.threads.untrash({ userId: 'me', id: params.id });
-            return JSON.stringify(data);
-        },
-    });
-}
+// Gmail Thread tools
+import { z } from 'zod';
+import { getGmailClient } from '../../clients.js';
+import { processMessagePart } from '../../helpers.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'get_thread',
+        description: 'Get a specific thread by ID',
+        parameters: z.object({
+            id: z.string().describe("The ID of the thread 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.threads.get({ userId: 'me', id: params.id, format: 'full' });
+            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: 'list_threads',
+        description: 'List threads in the user\'s mailbox',
+        parameters: z.object({
+            maxResults: z.number().optional().describe("Maximum number of threads to return"),
+            pageToken: z.string().optional().describe("Page token to retrieve a specific page of results"),
+            q: z.string().optional().describe("Only return threads matching the specified query"),
+            labelIds: z.array(z.string()).optional().describe("Only return threads with labels that match all specified label IDs"),
+            includeSpamTrash: z.boolean().optional().describe("Include threads 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.threads.list({ userId: 'me', ...params });
+            if (data.threads) {
+                data.threads = data.threads.map(thread => {
+                    if (thread.messages) {
+                        thread.messages = thread.messages.map(message => {
+                            if (message.payload) {
+                                message.payload = processMessagePart(message.payload, params.includeBodyHtml);
+                            }
+                            return message;
+                        });
+                    }
+                    return thread;
+                });
+            }
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'batch_get_threads',
+        description: 'Get multiple threads by ID in parallel. More efficient than calling get_thread multiple times.',
+        parameters: z.object({
+            ids: z.array(z.string()).describe("The IDs of the threads 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.threads.get({ userId: 'me', id, format: 'full' });
+                        if (data.messages) {
+                            data.messages = data.messages.map(message => {
+                                if (message.payload) {
+                                    message.payload = processMessagePart(message.payload, params.includeBodyHtml);
+                                }
+                                return message;
+                            });
+                        }
+                        return data;
+                    } catch (error) {
+                        return { id, error: error.message || 'Failed to retrieve thread' };
+                    }
+                })
+            );
+            return JSON.stringify(results);
+        },
+    });
+
+    server.addTool({
+        name: 'modify_thread',
+        description: 'Modify the labels applied to a thread',
+        parameters: z.object({
+            id: z.string().describe("The ID of the thread 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 { id, ...threadData } = params;
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.threads.modify({ userId: 'me', id, requestBody: threadData });
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'delete_thread',
+        description: 'Delete a thread',
+        parameters: z.object({
+            id: z.string().describe("The ID of the thread to delete"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.threads.delete({ userId: 'me', id: params.id });
+            return JSON.stringify(data || { success: true });
+        },
+    });
+
+    server.addTool({
+        name: 'trash_thread',
+        description: 'Move a thread to the trash',
+        parameters: z.object({
+            id: z.string().describe("The ID of the thread to move to trash"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.threads.trash({ userId: 'me', id: params.id });
+            return JSON.stringify(data);
+        },
+    });
+
+    server.addTool({
+        name: 'untrash_thread',
+        description: 'Remove a thread from the trash',
+        parameters: z.object({
+            id: z.string().describe("The ID of the thread to remove from trash"),
+        }),
+        execute: async (params) => {
+            const gmail = await getGmailClient();
+            const { data } = await gmail.users.threads.untrash({ userId: 'me', id: params.id });
+            return JSON.stringify(data);
+        },
+    });
+}

package/dist/tools/index.js

@@ -74,6 +74,14 @@ const CATEGORIES = {
             register(server);
         },
     },
+    calendar: {
+        description: 'Google Calendar — list calendars, get/create/update/delete events, check busy times, find free slots, move events, recurring event instances, manage calendars',
+        toolCount: 8,
+        async loader(server) {
+            const { registerCalendarTools } = await import('./calendar/index.js');
+            registerCalendarTools(server);
+        },
+    },
 };
 
 // Track which categories have been loaded

package/dist/tools/labels.js

@@ -0,0 +1,103 @@
+// 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);
+        },
+    });
+
+    server.addTool({
+        name: 'update_label',
+        description: 'Update an existing label',
+        parameters: z.object({
+            id: z.string().describe("The ID of the label to update"),
+            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.update({ userId: 'me', id, requestBody: labelData });
+            return JSON.stringify(data);
+        },
+    });
+}