mcp-google-multi 5.2.0-alpha.1 → 5.2.0-alpha.2

package/dist/executor.d.ts

@@ -0,0 +1,39 @@
+import { getClient } from './client.js';
+export declare const MAX_RESPONSE_CHARS = 100000;
+export type QueryValue = string | number | boolean;
+export type QueryParams = Record<string, QueryValue | QueryValue[]>;
+export interface ApiMethodRef {
+    id: string;
+    httpMethod: string;
+    path: string;
+    baseUrl: string;
+    requiredParams: string[];
+}
+export interface ExecuteDeps {
+    getClientFn?: typeof getClient;
+}
+export interface ExecuteArgs {
+    account: string;
+    pathParams?: Record<string, string | number>;
+    queryParams?: QueryParams;
+    body?: unknown;
+}
+export declare function jsonResult(payload: unknown, isError?: boolean): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+} | {
+    isError: true;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
+export declare function buildQueryString(queryParams: QueryParams | undefined): string;
+export declare function executeApiMethod(method: ApiMethodRef, args: ExecuteArgs, deps?: ExecuteDeps): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/executor.js

@@ -0,0 +1,75 @@
+import { getClient } from './client.js';
+import { expandPath, isGoogleApiUrl } from './discovery-client.js';
+import { handleGoogleApiError } from './tools/_errors.js';
+export const MAX_RESPONSE_CHARS = 100_000;
+export function jsonResult(payload, isError = false) {
+    const base = { content: [{ type: 'text', text: JSON.stringify(payload) }] };
+    return isError ? { ...base, isError: true } : base;
+}
+export function buildQueryString(queryParams) {
+    const usp = new URLSearchParams();
+    const merged = { alt: 'json', ...queryParams };
+    for (const [key, value] of Object.entries(merged)) {
+        if (Array.isArray(value)) {
+            for (const v of value)
+                usp.append(key, String(v));
+        }
+        else {
+            usp.append(key, String(value));
+        }
+    }
+    return usp.toString();
+}
+export async function executeApiMethod(method, args, deps = {}) {
+    if (args.queryParams?.alt === 'media') {
+        return jsonResult({
+            error: 'binary_unsupported',
+            message: 'Binary media download (alt=media) returns no usable JSON through this tool.',
+            hint: 'Use drive_download / drive_export for file content.',
+            retriable: false,
+        }, true);
+    }
+    let url;
+    try {
+        url = method.baseUrl + expandPath(method.path, args.pathParams ?? {});
+    }
+    catch (err) {
+        return jsonResult({
+            error: 'invalid_params',
+            message: err.message,
+            hint: `Required params for ${method.id}: ${method.requiredParams.join(', ') || '(none)'}`,
+            retriable: false,
+        }, true);
+    }
+    if (!isGoogleApiUrl(url)) {
+        return jsonResult({
+            error: 'untrusted_host',
+            message: `Refusing to send credentials to a non-googleapis.com host for "${method.id}".`,
+            hint: 'The discovery cache may be corrupt; delete DISCOVERY_CACHE_PATH and retry.',
+            retriable: false,
+        }, true);
+    }
+    try {
+        const getClientFn = deps.getClientFn ?? getClient;
+        const auth = await getClientFn(args.account);
+        const res = await auth.request({
+            // query string built by hand: gaxios comma-joins arrays, Google needs repeated keys
+            url: `${url}?${buildQueryString(args.queryParams)}`,
+            method: method.httpMethod,
+            data: args.body ?? undefined,
+        });
+        const text = JSON.stringify(res.data ?? null);
+        if (text.length > MAX_RESPONSE_CHARS) {
+            return jsonResult({
+                truncated: true,
+                totalChars: text.length,
+                head: text.slice(0, MAX_RESPONSE_CHARS),
+                hint: 'Narrow the request (fields mask, pageSize) to get complete JSON.',
+            });
+        }
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        return handleGoogleApiError(error, args.account);
+    }
+}

package/dist/index.js

@@ -19,6 +19,7 @@ import { registerFormsTools } from './tools/forms.js';
 import { registerChatTools } from './tools/chat.js';
 import { registerAdminTools } from './tools/admin.js';
 import { getOptionalBundles, getAdminAccounts } from './auth.js';
+import { GENERATED_SERVICES } from './tools/generated/index.js';
 import { ToolRegistry } from './registry.js';
 import { registerDiscoverTools } from './discover.js';
 import { registerEscapeTools } from './tools/google-api.js';
@@ -42,11 +43,14 @@ const SERVICES = [
     { name: 'chat', register: registerChatTools, enabled: () => new Set(getOptionalBundles()).has('chat') },
     { name: 'admin', register: registerAdminTools, enabled: () => getAdminAccounts().length > 0 },
 ];
+// Opt-in gates for generated-only services whose scopes are not granted by
+// default; shared services (admin, forms, chat) reuse their curated gate below.
+const GENERATED_GATES = {};
 function buildRegistry(server, policy) {
     const registry = new ToolRegistry(server, policy);
     const toolsets = getToolsets();
     if (toolsets !== 'all') {
-        const known = new Set(SERVICES.map((s) => s.name));
+        const known = new Set([...SERVICES.map((s) => s.name), ...GENERATED_SERVICES.map((s) => s.name)]);
         for (const requested of toolsets) {
             if (!known.has(requested)) {
                 process.stderr.write(`GOOGLE_TOOLSETS: unknown service "${requested}" ignored\n`);
@@ -65,6 +69,19 @@ function buildRegistry(server, policy) {
         }
         svc.register(registry);
     }
+    for (const gen of GENERATED_SERVICES) {
+        if (!toolsetEnabled(toolsets, gen.name))
+            continue;
+        const curated = SERVICES.find((s) => s.name === gen.name);
+        const gate = curated?.enabled ?? GENERATED_GATES[gen.name]?.enabled;
+        if (gate && !gate()) {
+            if (!curated && toolsets !== 'all') {
+                process.stderr.write(`GOOGLE_TOOLSETS: "${gen.name}" requested but not enabled — ${GENERATED_GATES[gen.name].hint}\n`);
+            }
+            continue;
+        }
+        gen.register(registry);
+    }
     if (registry.services().length === 0) {
         throw new Error(`GOOGLE_TOOLSETS="${process.env.GOOGLE_TOOLSETS ?? ''}" selected no enabled services. ` +
             `Known services: ${SERVICES.map((s) => s.name).join(', ')}. ` +

package/dist/registry.js

@@ -44,7 +44,7 @@ export class ToolRegistry {
         this.policy = policy;
         this.registerTool = ((name, config, handler) => {
             const service = SERVICE_OVERRIDES[name] ?? (name.includes('_') ? name.slice(0, name.indexOf('_')) : name);
-            const cud = inferCud(name);
+            const cud = config.cud ?? inferCud(name);
             // destructiveHint=false claims "additive only" (MCP spec) — updates overwrite, so they stay true.
             const annotations = {
                 readOnlyHint: cud === 'read',
@@ -84,7 +84,8 @@ export class ToolRegistry {
             const finalHandler = this.compactOutput
                 ? async (...args) => compactResult(await guarded(...args))
                 : guarded;
-            return server.registerTool(name, { ...config, inputSchema: inputShape, annotations }, finalHandler);
+            const { cud: _cud, ...sdkConfig } = config;
+            return server.registerTool(name, { ...sdkConfig, inputSchema: inputShape, annotations }, finalHandler);
         });
     }
     registerMeta = ((name, config, handler) => {

package/dist/tools/generated/_shared.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { type ApiMethodRef, type ExecuteDeps } from '../../executor.js';
+import type { Cud, ToolRegistry } from '../../registry.js';
+export interface GeneratedParam {
+    field: string;
+    api: string;
+    location: 'path' | 'query';
+}
+export interface GeneratedToolDef {
+    name: string;
+    cud: Cud;
+    description: string;
+    method: ApiMethodRef;
+    params: GeneratedParam[];
+    hasBody: boolean;
+    shape: z.ZodRawShape;
+}
+export declare function accountField(): z.ZodEnum<{
+    [x: string]: string;
+}>;
+export declare function registerGeneratedTool(registry: ToolRegistry, def: GeneratedToolDef, deps?: ExecuteDeps): void;

package/dist/tools/generated/_shared.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { ACCOUNTS } from '../../accounts.js';
+import { executeApiMethod } from '../../executor.js';
+export function accountField() {
+    return z.enum(ACCOUNTS).describe('Google account alias');
+}
+export function registerGeneratedTool(registry, def, deps = {}) {
+    // Widened locally: `cud` is a registry extension the SDK config type doesn't
+    // carry; the registry reads it before handing the config to the SDK.
+    const register = registry.registerTool;
+    register(def.name, {
+        description: def.description,
+        inputSchema: def.shape,
+        cud: def.cud,
+        annotations: { openWorldHint: true },
+    }, async (args) => {
+        const pathParams = {};
+        const queryParams = {};
+        for (const p of def.params) {
+            const value = args[p.field];
+            if (value === undefined)
+                continue;
+            if (p.location === 'path')
+                pathParams[p.api] = value;
+            else
+                queryParams[p.api] = value;
+        }
+        return executeApiMethod(def.method, {
+            account: args.account,
+            pathParams,
+            queryParams,
+            body: def.hasBody ? args.body : undefined,
+        }, deps);
+    });
+}

package/dist/tools/generated/index.d.ts

@@ -0,0 +1,5 @@
+import type { ToolRegistry } from '../../registry.js';
+export declare const GENERATED_SERVICES: Array<{
+    name: string;
+    register: (registry: ToolRegistry) => void;
+}>;

package/dist/tools/generated/index.js

@@ -0,0 +1,4 @@
+import { registerTasksGeneratedTools } from './tasks.js';
+export const GENERATED_SERVICES = [
+    { name: "tasks", register: registerTasksGeneratedTools },
+];

package/dist/tools/generated/tasks.d.ts

@@ -0,0 +1,2 @@
+import type { ToolRegistry } from '../../registry.js';
+export declare function registerTasksGeneratedTools(registry: ToolRegistry): void;

package/dist/tools/generated/tasks.js

@@ -0,0 +1,35 @@
+// GENERATED by scripts/gen-tools.ts — do not edit. Regenerate: npm run gen:tools
+import { z } from 'zod';
+import { coerceJson } from '../_coerce.js';
+import { accountField, registerGeneratedTool } from './_shared.js';
+export function registerTasksGeneratedTools(registry) {
+    registerGeneratedTool(registry, {
+        name: "tasks_tasklists_update",
+        cud: "update",
+        description: "Updates the authenticated user's specified task list.",
+        method: { id: "tasks.tasklists.update", httpMethod: "PUT", path: "tasks/v1/users/@me/lists/{tasklist}", baseUrl: "https://tasks.googleapis.com/", requiredParams: ["tasklist"] },
+        params: [{ "field": "tasklist", "api": "tasklist", "location": "path" }, { "field": "fields", "api": "fields", "location": "query" }],
+        hasBody: true,
+        shape: {
+            account: accountField(),
+            tasklist: z.string().describe("Task list identifier."),
+            body: coerceJson(z.record(z.string(), z.unknown())).describe("TaskList JSON request body. Top-level fields: etag, id, kind, selfLink, title, updated."),
+            fields: z.string().optional().describe('Response field mask.'),
+        },
+    });
+    registerGeneratedTool(registry, {
+        name: "tasks_tasks_update",
+        cud: "update",
+        description: "Updates the specified task.",
+        method: { id: "tasks.tasks.update", httpMethod: "PUT", path: "tasks/v1/lists/{tasklist}/tasks/{task}", baseUrl: "https://tasks.googleapis.com/", requiredParams: ["tasklist", "task"] },
+        params: [{ "field": "task", "api": "task", "location": "path" }, { "field": "tasklist", "api": "tasklist", "location": "path" }, { "field": "fields", "api": "fields", "location": "query" }],
+        hasBody: true,
+        shape: {
+            account: accountField(),
+            task: z.string().describe("Task identifier."),
+            tasklist: z.string().describe("Task list identifier."),
+            body: coerceJson(z.record(z.string(), z.unknown())).describe("Task JSON request body. Top-level fields: assignmentInfo, completed, deleted, due, etag, hidden, id, kind, links, notes, parent, position, +5 more."),
+            fields: z.string().optional().describe('Response field mask.'),
+        },
+    });
+}

package/dist/tools/google-api.js

@@ -2,12 +2,11 @@ import { z } from 'zod';
 import { isAllowed, writeDisabledResult } from '../write-control.js';
 import { ACCOUNTS } from '../accounts.js';
 import { getClient } from '../client.js';
-import { handleGoogleApiError } from './_errors.js';
 import { coerceJson } from './_coerce.js';
 import { getToolsets, toolsetEnabled } from '../toolsets.js';
-import { WORKSPACE_APIS, cudFromMethod, expandPath, isGoogleApiUrl, loadMethodIndex, searchMethods, } from '../discovery-client.js';
+import { executeApiMethod, jsonResult } from '../executor.js';
+import { WORKSPACE_APIS, cudFromMethod, loadMethodIndex, searchMethods, } from '../discovery-client.js';
 const accountEnum = z.enum(ACCOUNTS);
-const MAX_RESPONSE_CHARS = 100_000;
 // Policy/toolset namespace for each API alias must match the NAMED tools' service
 // names, or user deny globs and GOOGLE_TOOLSETS silently miss escape-hatch calls.
 const SERVICE_FOR_ALIAS = {
@@ -29,24 +28,6 @@ const SERVICE_FOR_ALIAS = {
     admin_reports: 'admin',
     groupssettings: 'groupssettings',
 };
-function buildQueryString(queryParams) {
-    const usp = new URLSearchParams();
-    const merged = { alt: 'json', ...queryParams };
-    for (const [key, value] of Object.entries(merged)) {
-        if (Array.isArray(value)) {
-            for (const v of value)
-                usp.append(key, String(v));
-        }
-        else {
-            usp.append(key, String(value));
-        }
-    }
-    return usp.toString();
-}
-function jsonResult(payload, isError = false) {
-    const base = { content: [{ type: 'text', text: JSON.stringify(payload) }] };
-    return isError ? { ...base, isError: true } : base;
-}
 function describeMethod(m) {
     return {
         api: m.api,
@@ -134,14 +115,6 @@ export function registerEscapeTools(registry, policy, deps = {}) {
         }
         if (!apiEnabled(api))
             return toolsetDisabled(api);
-        if (queryParams?.alt === 'media') {
-            return jsonResult({
-                error: 'binary_unsupported',
-                message: 'Binary media download (alt=media) returns no usable JSON through the escape hatch.',
-                hint: 'Use drive_download / drive_export for file content.',
-                retriable: false,
-            }, true);
-        }
         let index;
         try {
             index = await loadMethodIndex(api, deps);
@@ -165,47 +138,11 @@ export function registerEscapeTools(registry, policy, deps = {}) {
         if (cud !== 'read' && !isAllowed(toolRef, policy)) {
             return writeDisabledResult(toolRef, policy);
         }
-        let url;
-        try {
-            url = method.baseUrl + expandPath(method.path, pathParams ?? {});
-        }
-        catch (err) {
-            return jsonResult({
-                error: 'invalid_params',
-                message: err.message,
-                hint: `Required params for ${method.id}: ${method.requiredParams.join(', ') || '(none)'}`,
-                retriable: false,
-            }, true);
-        }
-        if (!isGoogleApiUrl(url)) {
-            return jsonResult({
-                error: 'untrusted_host',
-                message: `Refusing to send credentials to a non-googleapis.com host for "${method.id}".`,
-                hint: 'The discovery cache may be corrupt; delete DISCOVERY_CACHE_PATH and retry.',
-                retriable: false,
-            }, true);
-        }
-        try {
-            const auth = await getClientFn(account);
-            const res = await auth.request({
-                // query string built by hand: gaxios comma-joins arrays, Google needs repeated keys
-                url: `${url}?${buildQueryString(queryParams)}`,
-                method: method.httpMethod,
-                data: body ?? undefined,
-            });
-            const text = JSON.stringify(res.data ?? null);
-            if (text.length > MAX_RESPONSE_CHARS) {
-                return jsonResult({
-                    truncated: true,
-                    totalChars: text.length,
-                    head: text.slice(0, MAX_RESPONSE_CHARS),
-                    hint: 'Narrow the request (fields mask, pageSize) to get complete JSON.',
-                });
-            }
-            return { content: [{ type: 'text', text }] };
-        }
-        catch (error) {
-            return handleGoogleApiError(error, account);
-        }
+        return executeApiMethod(method, {
+            account: account,
+            pathParams: pathParams,
+            queryParams: queryParams,
+            body,
+        }, { getClientFn });
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-google-multi",
-  "version": "5.2.0-alpha.1",
+  "version": "5.2.0-alpha.2",
   "description": "Local MCP server for Google Workspace (Gmail, Drive, Calendar, Sheets, Docs, Contacts, Tasks, Meet, Search Console, +Forms/Chat/Admin) across multiple accounts — OAuth-only, encrypted token storage, deny-by-default writes.",
   "type": "module",
   "license": "MIT",
@@ -55,7 +55,8 @@
     "typecheck": "tsc --noEmit && tsc -p tsconfig.scripts.json",
     "test": "vitest run",
     "test:watch": "vitest",
-    "gen:discovery": "tsx scripts/fetch-discovery.ts"
+    "gen:discovery": "tsx scripts/fetch-discovery.ts",
+    "gen:tools": "tsx scripts/gen-tools.ts"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",