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

package/dist/auth.js

@@ -39,6 +39,39 @@ export const OPTIONAL_SCOPE_BUNDLES = {
         'https://www.googleapis.com/auth/chat.messages',
         'https://www.googleapis.com/auth/chat.messages.create',
     ],
+    classroom: [
+        'https://www.googleapis.com/auth/classroom.courses',
+        'https://www.googleapis.com/auth/classroom.coursework.me',
+        'https://www.googleapis.com/auth/classroom.coursework.students',
+        'https://www.googleapis.com/auth/classroom.courseworkmaterials',
+        'https://www.googleapis.com/auth/classroom.rosters',
+        'https://www.googleapis.com/auth/classroom.announcements',
+        'https://www.googleapis.com/auth/classroom.topics',
+    ],
+    cloudidentity: [
+        'https://www.googleapis.com/auth/cloud-identity.groups',
+        'https://www.googleapis.com/auth/cloud-identity.devices',
+    ],
+    cloudsearch: ['https://www.googleapis.com/auth/cloud_search'],
+    vault: ['https://www.googleapis.com/auth/ediscovery'],
+    keep: ['https://www.googleapis.com/auth/keep'],
+    driveactivity: ['https://www.googleapis.com/auth/drive.activity.readonly'],
+    drivelabels: [
+        'https://www.googleapis.com/auth/drive.labels',
+        'https://www.googleapis.com/auth/drive.admin.labels',
+    ],
+    script: [
+        'https://www.googleapis.com/auth/script.projects',
+        'https://www.googleapis.com/auth/script.deployments',
+        'https://www.googleapis.com/auth/script.processes',
+        'https://www.googleapis.com/auth/script.metrics',
+    ],
+    postmaster: ['https://www.googleapis.com/auth/postmaster.readonly'],
+    groupssettings: ['https://www.googleapis.com/auth/apps.groups.settings'],
+    groupsmigration: ['https://www.googleapis.com/auth/apps.groups.migration'],
+    licensing: ['https://www.googleapis.com/auth/apps.licensing'],
+    reseller: ['https://www.googleapis.com/auth/apps.order'],
+    appsmarket: ['https://www.googleapis.com/auth/appsmarketplace.license'],
 };
 export const ADMIN_SCOPES = [
     'https://www.googleapis.com/auth/admin.reports.audit.readonly',

package/dist/discovery-client.js

@@ -18,7 +18,20 @@ export const WORKSPACE_APIS = {
     drivelabels: { id: 'drivelabels', version: 'v2' },
     admin_directory: { id: 'admin', version: 'directory_v1' },
     admin_reports: { id: 'admin', version: 'reports_v1' },
+    admin_datatransfer: { id: 'admin', version: 'datatransfer_v1' },
     groupssettings: { id: 'groupssettings', version: 'v1' },
+    appsmarket: { id: 'appsmarket', version: 'v2' },
+    classroom: { id: 'classroom', version: 'v1' },
+    cloudidentity: { id: 'cloudidentity', version: 'v1' },
+    cloudsearch: { id: 'cloudsearch', version: 'v1' },
+    groupsmigration: { id: 'groupsmigration', version: 'v1' },
+    keep: { id: 'keep', version: 'v1' },
+    licensing: { id: 'licensing', version: 'v1' },
+    postmaster: { id: 'gmailpostmastertools', version: 'v1' },
+    reseller: { id: 'reseller', version: 'v1' },
+    script: { id: 'script', version: 'v1' },
+    vault: { id: 'vault', version: 'v1' },
+    workspaceevents: { id: 'workspaceevents', version: 'v1' },
 };
 const TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const STALE_RETRY_MS = 5 * 60 * 1000;

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,35 @@ 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.
+// workspaceevents has no dedicated scope (subscriptions use the underlying
+// resource scopes), so it registers ungated.
+const bundleGate = (name) => ({
+    enabled: () => new Set(getOptionalBundles()).has(name),
+    hint: `add "${name}" to GOOGLE_OPTIONAL_SCOPES`,
+});
+const GENERATED_GATES = {
+    appsmarket: bundleGate('appsmarket'),
+    classroom: bundleGate('classroom'),
+    cloudidentity: bundleGate('cloudidentity'),
+    cloudsearch: bundleGate('cloudsearch'),
+    driveactivity: bundleGate('driveactivity'),
+    drivelabels: bundleGate('drivelabels'),
+    groupsmigration: bundleGate('groupsmigration'),
+    groupssettings: bundleGate('groupssettings'),
+    keep: bundleGate('keep'),
+    licensing: bundleGate('licensing'),
+    postmaster: bundleGate('postmaster'),
+    reseller: bundleGate('reseller'),
+    script: bundleGate('script'),
+    vault: bundleGate('vault'),
+};
 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,10 +90,24 @@ 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) {
+        const known = [...new Set([...SERVICES.map((s) => s.name), ...GENERATED_SERVICES.map((s) => s.name)])].sort();
         throw new Error(`GOOGLE_TOOLSETS="${process.env.GOOGLE_TOOLSETS ?? ''}" selected no enabled services. ` +
-            `Known services: ${SERVICES.map((s) => s.name).join(', ')}. ` +
-            `Note: slides/forms/chat require GOOGLE_OPTIONAL_SCOPES, admin requires GOOGLE_ADMIN_ACCOUNTS.`);
+            `Known services: ${known.join(', ')}. ` +
+            `Note: optional services require their bundle in GOOGLE_OPTIONAL_SCOPES, admin requires GOOGLE_ADMIN_ACCOUNTS.`);
     }
     registerDiscoverTools(registry, policy);
     registerEscapeTools(registry, policy);

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/admin.d.ts

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