google-tools-mcp 1.2.11 → 2.0.0

package/dist/tools/forms/getForm.js

@@ -1,118 +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'}`);
-            }
-        },
-    });
-}
+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

@@ -1,45 +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'}`);
-            }
-        },
-    });
-}
+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

@@ -1,15 +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);
-}
+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

@@ -1,56 +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'}`);
-            }
-        },
-    });
-}
+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

@@ -1,59 +1,59 @@
-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({
-                    url: `https://docs.google.com/forms/d/${args.formId}/edit`,
-                    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'}`);
-            }
-        },
-    });
-}
+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({
+                    url: `https://docs.google.com/forms/d/${args.formId}/edit`,
+                    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'}`);
+            }
+        },
+    });
+}