google-tools-mcp 1.0.1 → 1.0.3

package/README.md

@@ -1,20 +1,19 @@
 # google-tools-mcp
 
-A unified MCP server for Google Workspace — Drive, Docs, Sheets, Gmail, and Calendar — with **lazy-loaded tool categories** to keep your context window lean.
+A unified MCP server for Google Workspace — Drive, Docs, Sheets, Gmail, and Calendar — with **146 tools** across 8 categories.
 
-Only 2 tools are exposed at startup. When the AI agent needs a Google service, it calls `load_google_tools` to load just the relevant category. No bloat, no wasted context.
+All tools are loaded at startup so they're immediately available to your AI agent. No discovery step needed.
 
 ## Why This Exists
 
-Most Google MCP servers dump 70+ tool definitions into your context on startup. If you need both Drive and Gmail, that's 140+ tools competing for attention before a single useful thing happens.
-
-This server starts with **2 tools** and loads categories on demand — so you only pay the context cost for what you actually use.
+Most Google MCP servers split functionality across separate packages. This server combines everything into one — single auth token, single process, single config.
 
 ## Features
 
-- **Lazy-loaded tools** — 146 tools across 8 categories, loaded only when needed
+- **146 tools** across 8 categories, all available immediately
 - **Single auth token** — one OAuth flow covers Drive, Docs, Sheets, Gmail, and Calendar
 - **Lazy-loading auth** — no browser popup until your first tool call
+- **No lazy tool loading** — all 146 tools are registered eagerly at startup since most MCP clients (including Claude Code) don't support `notifications/tools/list_changed`
 - **Multi-profile support** — separate tokens per Google account
 - **No telemetry**
 
@@ -169,8 +168,6 @@ This stores tokens in `~/.config/google-tools-mcp/work/` instead of the default
 
 ## Tool Categories
 
-Call `load_google_tools` with one or more category names to load them. You can load multiple at once.
-
 ### `files` (16 tools)
 Google Drive file management and content reading.
 
@@ -230,7 +227,7 @@ This package replaces both [`gdrive-tools-mcp`](https://www.npmjs.com/package/gd
 
 1. Replace both MCP server entries with a single `google-tools-mcp` entry
 2. Re-authenticate (the combined server uses its own config dir at `~/.config/google-tools-mcp/`)
-3. All the same tools are available — the agent just needs to call `load_google_tools` first
+3. All tools are available immediately — no discovery step needed
 
 ## License
 

package/dist/auth.js

@@ -48,6 +48,10 @@ const SCOPES = [
     'https://www.googleapis.com/auth/gmail.settings.sharing',
     // Calendar
     'https://www.googleapis.com/auth/calendar',
+    // Forms
+    'https://www.googleapis.com/auth/forms.body',
+    'https://www.googleapis.com/auth/forms.body.readonly',
+    'https://www.googleapis.com/auth/forms.responses.readonly',
 ];
 
 // ---------------------------------------------------------------------------

package/dist/clients.js

@@ -12,6 +12,7 @@ let googleSheets = null;
 let googleScript = null;
 let gmailClient = null;
 let calendarClient = null;
+let formsClient = null;
 
 async function ensureAuth() {
     if (authClient) return;
@@ -58,6 +59,14 @@ export async function initializeCalendarClient() {
     return { authClient, calendarClient };
 }
 
+// --- Forms client ---
+export async function initializeFormsClient() {
+    if (formsClient) return { authClient, formsClient };
+    await ensureAuth();
+    if (!formsClient) formsClient = google.forms({ version: 'v1', auth: authClient });
+    return { authClient, formsClient };
+}
+
 // --- Reset all clients (used by logout) ---
 export function resetClients() {
     authClient = null;
@@ -67,6 +76,7 @@ export function resetClients() {
     googleScript = null;
     gmailClient = null;
     calendarClient = null;
+    formsClient = null;
 }
 
 // --- Individual client getters ---
@@ -111,3 +121,9 @@ export async function getCalendarClient() {
     if (!calendar) throw new UserError('Google Calendar client is not initialized.');
     return calendar;
 }
+
+export async function getFormsClient() {
+    const { formsClient: forms } = await initializeFormsClient();
+    if (!forms) throw new UserError('Google Forms client is not initialized.');
+    return forms;
+}

package/dist/index.js

@@ -1,14 +1,13 @@
 #!/usr/bin/env node
 // google-tools-mcp — Combined Google Workspace MCP server
 //
-// Provides lazy-loaded tool categories for Drive, Docs, Sheets, and Gmail.
-// Only a discovery tool is exposed at startup; individual tools are loaded on demand.
+// All tool categories (Drive, Docs, Sheets, Gmail, Calendar) are loaded at
+// startup so they're available in the initial tools/list response.
 //
 // Usage:
 //   google-tools-mcp          Start the MCP server (default)
 //   google-tools-mcp auth     Run the interactive OAuth flow
 import { FastMCP } from 'fastmcp';
-import { collectToolsWhileRegistering, installCachedToolsListHandler } from './cachedToolsList.js';
 import { registerAllTools } from './tools/index.js';
 import { logger } from './logger.js';
 
@@ -38,17 +37,13 @@ const server = new FastMCP({
     version: '1.0.0',
 });
 
-const registeredTools = [];
-collectToolsWhileRegistering(server, registeredTools);
-registerAllTools(server);
+await registerAllTools(server);
 
 try {
     logger.info('Starting google-tools-mcp server...');
     await server.start({ transportType: 'stdio' });
-    installCachedToolsListHandler(server, registeredTools);
     logger.info('MCP Server running using stdio. Awaiting client connection...');
     logger.info('Google auth will run automatically on first tool call.');
-    logger.info(`${registeredTools.length} tools registered at startup (discovery + logout). Call load_google_tools to load more.`);
 } catch (startError) {
     logger.error('FATAL: Server failed to start:', startError.message || startError);
     process.exit(1);

package/dist/tools/forms/batchUpdateForm.js

@@ -0,0 +1,80 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getFormsClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'batch_update_form',
+        description:
+            'Applies one or more updates to a Google Form. Supports creating, updating, deleting, and moving items, as well as updating form info and settings. ' +
+            'Each request in the array should be an object with exactly one key: createItem, updateItem, deleteItem, moveItem, updateFormInfo, or updateSettings. ' +
+            'See the Google Forms API batchUpdate documentation for the full request schema.',
+        parameters: z.object({
+            formId: z.string().describe('The ID of the Google Form to update'),
+            requests: z
+                .array(z.record(z.any()))
+                .min(1)
+                .describe(
+                    'Array of update requests. Each object should have one key: createItem, updateItem, deleteItem, moveItem, updateFormInfo, or updateSettings',
+                ),
+        }),
+        execute: async (args, { log }) => {
+            const forms = await getFormsClient();
+            log.info(`Batch updating form ${args.formId} with ${args.requests.length} request(s)`);
+
+            const validKeys = new Set([
+                'createItem',
+                'updateItem',
+                'deleteItem',
+                'moveItem',
+                'updateFormInfo',
+                'updateSettings',
+            ]);
+
+            for (const req of args.requests) {
+                const keys = Object.keys(req);
+                if (keys.length !== 1 || !validKeys.has(keys[0])) {
+                    throw new UserError(
+                        `Invalid request object. Each request must have exactly one key from: ${[...validKeys].join(', ')}. Got: ${keys.join(', ')}`,
+                    );
+                }
+            }
+
+            try {
+                const response = await forms.forms.batchUpdate({
+                    formId: args.formId,
+                    requestBody: { requests: args.requests },
+                });
+                const data = response.data;
+                const replies = data.replies || [];
+
+                const result = {
+                    requestsApplied: args.requests.length,
+                    repliesReceived: replies.length,
+                };
+
+                const createdItems = [];
+                for (const reply of replies) {
+                    if (reply.createItem) {
+                        const ci = reply.createItem;
+                        createdItems.push({
+                            itemId: ci.itemId,
+                            questionId: ci.questionId?.[0] || null,
+                        });
+                    }
+                }
+                if (createdItems.length > 0) {
+                    result.createdItems = createdItems;
+                }
+
+                return JSON.stringify(result, null, 2);
+            } catch (error) {
+                log.error(`Error batch updating form: ${error.message || error}`);
+                if (error.code === 401)
+                    throw new UserError('Authentication failed. Try logging out and re-authenticating.');
+                if (error.code === 404) throw new UserError(`Form not found: ${args.formId}`);
+                throw new UserError(`Failed to batch update form: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/forms/createForm.js

@@ -0,0 +1,54 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getFormsClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'create_form',
+        description:
+            'Creates a new Google Form with a title and optional description. Returns the form ID, edit URL, and responder URL.',
+        parameters: z.object({
+            title: z.string().describe('The title of the form (shown to respondents)'),
+            description: z.string().optional().describe('A description displayed at the top of the form'),
+            documentTitle: z
+                .string()
+                .optional()
+                .describe('The document title (shown in Drive). Defaults to the form title if not provided'),
+        }),
+        execute: async (args, { log }) => {
+            const forms = await getFormsClient();
+            log.info(`Creating form: ${args.title}`);
+
+            const body = {
+                info: {
+                    title: args.title,
+                    documentTitle: args.documentTitle || args.title,
+                },
+            };
+            if (args.description) {
+                body.info.description = args.description;
+            }
+
+            try {
+                const response = await forms.forms.create({ requestBody: body });
+                const form = response.data;
+
+                return JSON.stringify(
+                    {
+                        formId: form.formId,
+                        title: form.info?.title,
+                        editUrl: `https://docs.google.com/forms/d/${form.formId}/edit`,
+                        responderUrl: form.responderUri || `https://docs.google.com/forms/d/${form.formId}/viewform`,
+                    },
+                    null,
+                    2,
+                );
+            } catch (error) {
+                log.error(`Error creating form: ${error.message || error}`);
+                if (error.code === 401)
+                    throw new UserError('Authentication failed. Try logging out and re-authenticating.');
+                throw new UserError(`Failed to create form: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/forms/getForm.js

@@ -0,0 +1,118 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getFormsClient } from '../../clients.js';
+
+function extractOptionValues(options) {
+    if (!options) return [];
+    return options.filter((o) => o.value).map((o) => {
+        const opt = { value: o.value };
+        if (o.isOther) opt.isOther = true;
+        if (o.image) opt.image = o.image;
+        if (o.goToAction) opt.goToAction = o.goToAction;
+        if (o.goToSectionId) opt.goToSectionId = o.goToSectionId;
+        return opt;
+    });
+}
+
+function getQuestionType(question) {
+    if (question.choiceQuestion) return question.choiceQuestion.type || 'RADIO';
+    if (question.textQuestion) {
+        return question.textQuestion.paragraph ? 'PARAGRAPH' : 'TEXT';
+    }
+    if (question.scaleQuestion) return 'SCALE';
+    if (question.dateQuestion) return 'DATE';
+    if (question.timeQuestion) return 'TIME';
+    if (question.fileUploadQuestion) return 'FILE_UPLOAD';
+    if (question.ratingQuestion) return 'RATING';
+    if (question.rowQuestion) return 'GRID_ROW';
+    return 'QUESTION';
+}
+
+function serializeFormItem(item, index) {
+    const result = {
+        index,
+        itemId: item.itemId,
+        title: item.title || '',
+        description: item.description || '',
+    };
+
+    if (item.questionItem) {
+        const q = item.questionItem.question;
+        result.type = getQuestionType(q);
+        result.required = q.required || false;
+        result.questionId = q.questionId || null;
+        if (q.choiceQuestion) {
+            result.options = extractOptionValues(q.choiceQuestion.options);
+        }
+    } else if (item.questionGroupItem) {
+        const group = item.questionGroupItem;
+        result.type = 'GRID';
+        result.grid = {
+            columns: group.grid?.columns?.options
+                ? extractOptionValues(group.grid.columns.options)
+                : [],
+        };
+        if (group.questions) {
+            result.grid.rows = group.questions.map((q) => ({
+                questionId: q.questionId,
+                title: q.rowQuestion?.title || '',
+                required: q.required || false,
+            }));
+        }
+    } else if (item.pageBreakItem !== undefined) {
+        result.type = 'PAGE_BREAK';
+    } else if (item.textItem !== undefined) {
+        result.type = 'TEXT_ITEM';
+    } else if (item.imageItem) {
+        result.type = 'IMAGE';
+    } else if (item.videoItem) {
+        result.type = 'VIDEO';
+    } else {
+        result.type = 'UNKNOWN';
+    }
+
+    return result;
+}
+
+export function register(server) {
+    server.addTool({
+        name: 'get_form',
+        description:
+            'Retrieves a Google Form by ID. Returns the form title, description, URLs, and all items (questions, sections, images, etc.) with their types, options, and metadata.',
+        parameters: z.object({
+            formId: z.string().describe('The ID of the Google Form to retrieve'),
+        }),
+        execute: async (args, { log }) => {
+            const forms = await getFormsClient();
+            log.info(`Getting form: ${args.formId}`);
+
+            try {
+                const response = await forms.forms.get({ formId: args.formId });
+                const form = response.data;
+                const items = (form.items || []).map((item, i) => serializeFormItem(item, i));
+
+                return JSON.stringify(
+                    {
+                        formId: form.formId,
+                        title: form.info?.title || '',
+                        description: form.info?.description || '',
+                        documentTitle: form.info?.documentTitle || '',
+                        editUrl: `https://docs.google.com/forms/d/${form.formId}/edit`,
+                        responderUrl:
+                            form.responderUri || `https://docs.google.com/forms/d/${form.formId}/viewform`,
+                        itemCount: items.length,
+                        items,
+                    },
+                    null,
+                    2,
+                );
+            } catch (error) {
+                log.error(`Error getting form: ${error.message || error}`);
+                if (error.code === 401)
+                    throw new UserError('Authentication failed. Try logging out and re-authenticating.');
+                if (error.code === 404) throw new UserError(`Form not found: ${args.formId}`);
+                throw new UserError(`Failed to get form: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/forms/getFormResponse.js

@@ -0,0 +1,45 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getFormsClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'get_form_response',
+        description:
+            'Retrieves a single response from a Google Form by response ID. Returns the response timestamps and all answers keyed by question ID.',
+        parameters: z.object({
+            formId: z.string().describe('The ID of the Google Form'),
+            responseId: z.string().describe('The ID of the specific response to retrieve'),
+        }),
+        execute: async (args, { log }) => {
+            const forms = await getFormsClient();
+            log.info(`Getting response ${args.responseId} for form: ${args.formId}`);
+
+            try {
+                const response = await forms.forms.responses.get({
+                    formId: args.formId,
+                    responseId: args.responseId,
+                });
+                const r = response.data;
+
+                return JSON.stringify(
+                    {
+                        responseId: r.responseId,
+                        createTime: r.createTime,
+                        lastSubmittedTime: r.lastSubmittedTime,
+                        answers: r.answers || {},
+                    },
+                    null,
+                    2,
+                );
+            } catch (error) {
+                log.error(`Error getting form response: ${error.message || error}`);
+                if (error.code === 401)
+                    throw new UserError('Authentication failed. Try logging out and re-authenticating.');
+                if (error.code === 404)
+                    throw new UserError(`Form or response not found: ${args.formId} / ${args.responseId}`);
+                throw new UserError(`Failed to get form response: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/forms/index.js

@@ -0,0 +1,15 @@
+import { register as createForm } from './createForm.js';
+import { register as getForm } from './getForm.js';
+import { register as listFormResponses } from './listFormResponses.js';
+import { register as getFormResponse } from './getFormResponse.js';
+import { register as batchUpdateForm } from './batchUpdateForm.js';
+import { register as setPublishSettings } from './setPublishSettings.js';
+
+export function registerFormsTools(server) {
+    createForm(server);
+    getForm(server);
+    listFormResponses(server);
+    getFormResponse(server);
+    batchUpdateForm(server);
+    setPublishSettings(server);
+}

package/dist/tools/forms/listFormResponses.js

@@ -0,0 +1,56 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getFormsClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'list_form_responses',
+        description:
+            'Lists responses submitted to a Google Form. Returns a paginated list of responses with timestamps and answers.',
+        parameters: z.object({
+            formId: z.string().describe('The ID of the Google Form'),
+            pageSize: z
+                .number()
+                .min(1)
+                .max(5000)
+                .optional()
+                .describe('Number of responses to return per page (default 10, max 5000)'),
+            pageToken: z.string().optional().describe('Token for fetching the next page of results'),
+        }),
+        execute: async (args, { log }) => {
+            const forms = await getFormsClient();
+            log.info(`Listing responses for form: ${args.formId}`);
+
+            const params = { formId: args.formId };
+            if (args.pageSize) params.pageSize = args.pageSize;
+            if (args.pageToken) params.pageToken = args.pageToken;
+
+            try {
+                const response = await forms.forms.responses.list(params);
+                const data = response.data;
+                const responses = (data.responses || []).map((r) => ({
+                    responseId: r.responseId,
+                    createTime: r.createTime,
+                    lastSubmittedTime: r.lastSubmittedTime,
+                    answers: r.answers || {},
+                }));
+
+                return JSON.stringify(
+                    {
+                        totalResponses: responses.length,
+                        nextPageToken: data.nextPageToken || null,
+                        responses,
+                    },
+                    null,
+                    2,
+                );
+            } catch (error) {
+                log.error(`Error listing form responses: ${error.message || error}`);
+                if (error.code === 401)
+                    throw new UserError('Authentication failed. Try logging out and re-authenticating.');
+                if (error.code === 404) throw new UserError(`Form not found: ${args.formId}`);
+                throw new UserError(`Failed to list form responses: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/forms/setPublishSettings.js

@@ -0,0 +1,58 @@
+import { UserError } from 'fastmcp';
+import { z } from 'zod';
+import { getFormsClient } from '../../clients.js';
+
+export function register(server) {
+    server.addTool({
+        name: 'set_publish_settings',
+        description:
+            'Updates the publish settings of a Google Form. Controls whether the form is published as a template and whether respondents must be authenticated.',
+        parameters: z.object({
+            formId: z.string().describe('The ID of the Google Form'),
+            publishAsTemplate: z
+                .boolean()
+                .optional()
+                .describe('Whether to publish the form as a reusable template'),
+            requireAuthentication: z
+                .boolean()
+                .optional()
+                .describe('Whether respondents must sign in with a Google account to submit the form'),
+        }),
+        execute: async (args, { log }) => {
+            const forms = await getFormsClient();
+            log.info(`Setting publish settings for form: ${args.formId}`);
+
+            const body = {};
+            if (args.publishAsTemplate !== undefined) {
+                body.publishAsTemplate = args.publishAsTemplate;
+            }
+            if (args.requireAuthentication !== undefined) {
+                body.requireAuthentication = args.requireAuthentication;
+            }
+
+            if (Object.keys(body).length === 0) {
+                throw new UserError('At least one setting (publishAsTemplate or requireAuthentication) must be provided.');
+            }
+
+            try {
+                await forms.forms.setPublishSettings({
+                    formId: args.formId,
+                    requestBody: body,
+                });
+
+                return JSON.stringify({
+                    success: true,
+                    formId: args.formId,
+                    message: 'Publish settings updated successfully.',
+                    appliedSettings: body,
+                }, null, 2);
+            } catch (error) {
+                log.error(`Error setting publish settings: ${error.message || error}`);
+                if (error.code === 401)
+                    throw new UserError('Authentication failed. Try logging out and re-authenticating.');
+                if (error.code === 404) throw new UserError(`Form not found: ${args.formId}`);
+                throw new UserError(`Failed to set publish settings: ${error.message || 'Unknown error'}`);
+            }
+        },
+    });
+}

package/dist/tools/index.js

@@ -1,8 +1,6 @@
-// Tool discovery and lazy-loading registration.
-//
-// Only the `load_google_tools` discovery tool is registered at startup.
-// When a category is loaded, its tools are dynamically registered and the
-// client is notified via tools/list_changed so it picks them up.
+// Tool registration — all categories loaded eagerly at startup.
+// (Claude Code doesn't support notifications/tools/list_changed,
+//  so lazy-loading doesn't work.)
 import { z } from 'zod';
 import * as fs from 'fs/promises';
 import { getTokenPath } from '../auth.js';
@@ -10,11 +8,8 @@ import { resetClients } from '../clients.js';
 import { logger } from '../logger.js';
 
 // --- Category registry ---
-// Maps category names to { loader, description, toolCount }
 const CATEGORIES = {
     files: {
-        description: 'Google Drive file management — list, search, create, copy, move, rename, delete files/folders, read file contents (pdf, docx), search within files',
-        toolCount: 16,
         async loader(server) {
             const { registerDriveTools } = await import('./drive/index.js');
             const { registerExtrasTools } = await import('./extras/index.js');
@@ -23,8 +18,6 @@ const CATEGORIES = {
         },
     },
     documents: {
-        description: 'Google Docs — read, write, insert text/tables/images, formatting, comments, tabs, markdown conversion',
-        toolCount: 23,
         async loader(server) {
             const { registerDocsTools } = await import('./docs/index.js');
             const { registerUtilsTools } = await import('./utils/index.js');
@@ -33,16 +26,12 @@ const CATEGORIES = {
         },
     },
     spreadsheets: {
-        description: 'Google Sheets — read, write, format cells, charts, tables, conditional formatting, data validation',
-        toolCount: 30,
         async loader(server) {
             const { registerSheetsTools } = await import('./sheets/index.js');
             registerSheetsTools(server);
         },
     },
     email: {
-        description: 'Gmail — send, reply, forward, get, list, delete, trash messages, create/update/send drafts, attachments, batch operations',
-        toolCount: 19,
         async loader(server) {
             const { register: registerMessages } = await import('./gmail/messages.js');
             const { register: registerDrafts } = await import('./gmail/drafts.js');
@@ -51,102 +40,46 @@ const CATEGORIES = {
         },
     },
     email_threads: {
-        description: 'Gmail threads — get, list, batch get, modify, delete, trash/untrash conversation threads',
-        toolCount: 7,
         async loader(server) {
             const { register } = await import('./gmail/threads.js');
             register(server);
         },
     },
     email_labels: {
-        description: 'Gmail labels — create, delete, get, list, update labels for organizing email',
-        toolCount: 6,
         async loader(server) {
             const { register } = await import('./gmail/labels.js');
             register(server);
         },
     },
     email_settings: {
-        description: 'Gmail settings — auto-forwarding, IMAP, POP, vacation responder, delegates, filters, forwarding addresses, send-as aliases, S/MIME, profile, mailbox watch',
-        toolCount: 37,
         async loader(server) {
             const { register } = await import('./gmail/settings.js');
             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);
         },
     },
+    forms: {
+        async loader(server) {
+            const { registerFormsTools } = await import('./forms/index.js');
+            registerFormsTools(server);
+        },
+    },
 };
 
-// Track which categories have been loaded
-const loadedCategories = new Set();
-
 // ---------------------------------------------------------------------------
-// Notify the MCP client that the tool list has changed
+// Public: register all tools eagerly, plus the logout utility.
 // ---------------------------------------------------------------------------
-function notifyToolsChanged(server) {
-    try {
-        const session = server.sessions?.[0];
-        if (session?.server?.notification) {
-            session.server.notification({ method: 'notifications/tools/list_changed' });
-            logger.debug('Sent tools/list_changed notification.');
-        } else {
-            logger.debug('No session available for tools/list_changed notification.');
-        }
-    } catch (err) {
-        logger.warn('Failed to send tools/list_changed notification:', err.message);
+export async function registerAllTools(server) {
+    // Load every category
+    for (const [name, { loader }] of Object.entries(CATEGORIES)) {
+        await loader(server);
     }
-}
-
-// ---------------------------------------------------------------------------
-// Public: register the discovery tool (and logout)
-// ---------------------------------------------------------------------------
-export function registerAllTools(server) {
-    // --- Discovery tool ---
-    server.addTool({
-        name: 'load_google_tools',
-        description:
-            'Load Google Workspace tools by category. Call this first before using any Google service.\n\n' +
-            'Categories:\n' +
-            Object.entries(CATEGORIES)
-                .map(([name, { description, toolCount }]) => `  • ${name} (${toolCount} tools) — ${description}`)
-                .join('\n') +
-            '\n\nYou can load multiple categories at once by passing an array.',
-        parameters: z.object({
-            categories: z
-                .array(z.enum(Object.keys(CATEGORIES)))
-                .describe('One or more category names to load'),
-        }),
-        execute: async ({ categories }, { log }) => {
-            const results = [];
-            for (const cat of categories) {
-                if (loadedCategories.has(cat)) {
-                    results.push({ category: cat, status: 'already_loaded' });
-                    continue;
-                }
-                log.info(`Loading category: ${cat}`);
-                await CATEGORIES[cat].loader(server);
-                loadedCategories.add(cat);
-                results.push({
-                    category: cat,
-                    status: 'loaded',
-                    toolCount: CATEGORIES[cat].toolCount,
-                });
-            }
-            notifyToolsChanged(server);
-            return JSON.stringify({
-                loaded: results,
-                message: 'Tools are now available. You can call them directly.',
-                all_loaded_categories: [...loadedCategories],
-            });
-        },
-    });
+    logger.info(`Loaded all ${Object.keys(CATEGORIES).length} categories at startup.`);
 
     // --- Logout tool (always available) ---
     server.addTool({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "google-tools-mcp",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Combined Google Workspace MCP server (Drive, Docs, Sheets, Gmail) with lazy-loaded tool categories",
   "type": "module",
   "bin": {