mcp-google-multi 6.0.0-alpha.20 → 6.0.0-alpha.22

package/dist/discover.js

@@ -1,8 +1,32 @@
 import { z } from 'zod';
 import { describePolicy } from './write-control.js';
+// The description budget is the whole point of lazy mode: a full op list per
+// service put lazy tools/list at ~11.5k tokens (RQ2), so descriptions carry a
+// CAPPED vocabulary and the complete catalog stays in this tool's RESULT.
+const CURATED_OPS_CAP = 10;
+const GENERATED_GROUPS_CAP = 6;
 function opVocabulary(registry, service) {
-    const ops = registry.catalog(service).map((o) => o.tool.startsWith(`${service}_`) ? o.tool.slice(service.length + 1) : o.tool);
-    return [...new Set(ops)].join(', ');
+    const { curated, generated } = registry.opNames(service);
+    const parts = [];
+    if (curated.length > 0) {
+        const shown = curated.slice(0, CURATED_OPS_CAP);
+        const more = curated.length - shown.length;
+        parts.push(`${shown.join(', ')}${more > 0 ? ` +${more} more` : ''}`);
+    }
+    if (generated.length > 0) {
+        // The generated long tail compresses to its resource groups: denser and
+        // more selective than any truncated name list.
+        const counts = new Map();
+        for (const op of generated) {
+            const group = op.split('_')[0];
+            counts.set(group, (counts.get(group) ?? 0) + 1);
+        }
+        const groups = [...counts.entries()].sort((a, b) => b[1] - a[1]);
+        const shown = groups.slice(0, GENERATED_GROUPS_CAP).map(([g]) => g);
+        const more = groups.length - shown.length;
+        parts.push(`${generated.length} generated ops: ${shown.join(', ')}${more > 0 ? ` +${more} areas` : ''}`);
+    }
+    return parts.join('; ');
 }
 export function registerDiscoverTools(registry, policy) {
     const registerMeta = registry.registerMeta;
@@ -11,9 +35,8 @@ export function registerDiscoverTools(registry, policy) {
     // name/schema context budget after. stdio-only semantics — over stateless
     // HTTP the mode is forced curated and these are no-ops.
     registerMeta('discover_all', {
-        description: 'Reveal ALL curated Google tools at once (instead of per-service discovery). ' +
-            'Use when starting substantial Google work so the shaped, high-quality tools are ' +
-            'directly callable; prefer them over google_api_call. Pair with discover_reset when done.',
+        description: 'Reveal ALL curated Google tools at once (instead of per-service discovery). Use when ' +
+            'starting substantial Google work; prefer these over google_api_call. Pair with discover_reset.',
         inputSchema: {},
         _meta: { 'anthropic/alwaysLoad': true },
     }, async () => {
@@ -35,9 +58,8 @@ export function registerDiscoverTools(registry, policy) {
         };
     });
     registerMeta('discover_reset', {
-        description: 'Collapse the tool surface back to the configured default (lean meta-tools-only under the ' +
-            'default lazy mode), reclaiming context budget after heavy Google work. All tools remain ' +
-            'callable by name after collapsing.',
+        description: 'Collapse the tool surface back to the configured default, reclaiming context budget ' +
+            'after heavy Google work. All tools remain callable by name after collapsing.',
         inputSchema: {},
         _meta: { 'anthropic/alwaysLoad': true },
     }, async () => {
@@ -58,13 +80,12 @@ export function registerDiscoverTools(registry, policy) {
     });
     for (const service of registry.services()) {
         registerMeta(`${service}_discover`, {
-            description: `List the available ${service} operations. ` +
-                (registry.mode === 'lazy'
-                    ? `Operational ${service} tools are hidden until discovered — call this first, then call the tool you need by name. `
-                    : `Returns the ${service} catalog (and reveals any still-hidden ${service} tools). `) +
-                `Operations: ${opVocabulary(registry, service)}.`,
+            description: (registry.mode === 'lazy'
+                ? `Discover ${service}: lists the catalog and reveals its hidden tools; call first, then call the tool by name. `
+                : `List the ${service} catalog (reveals any still-hidden ${service} tools). `) +
+                `Ops: ${opVocabulary(registry, service)}.`,
             inputSchema: {
-                query: z.string().optional().describe('Keyword to filter the returned operations'),
+                query: z.string().optional().describe('Filter keyword'),
             },
             _meta: { 'anthropic/alwaysLoad': true },
         }, async ({ query }) => {

package/dist/registry.d.ts

@@ -54,6 +54,13 @@ export declare class ToolRegistry {
      * normalization; the kind drives value coercion on renamed keys). */
     argShape(name: string): ArgShape | undefined;
     catalog(service: string, query?: string): CatalogOperation[];
+    /** Op-name vocabulary for a service, split by provenance so the capped
+     * discover descriptions can list curated ops and only summarize the
+     * generated long tail. */
+    opNames(service: string): {
+        curated: string[];
+        generated: string[];
+    };
     reveal(service: string): boolean;
     /** discover_all: advertise the full curated set at once. Idempotent. */
     expand(): boolean;

package/dist/registry.js

@@ -237,6 +237,20 @@ export class ToolRegistry {
             cud: t.cud,
         }));
     }
+    /** Op-name vocabulary for a service, split by provenance so the capped
+     * discover descriptions can list curated ops and only summarize the
+     * generated long tail. */
+    opNames(service) {
+        const strip = (n) => (n.startsWith(`${service}_`) ? n.slice(service.length + 1) : n);
+        const curated = [];
+        const generated = [];
+        for (const t of this.tools) {
+            if (t.meta || t.service !== service)
+                continue;
+            (t.generated ? generated : curated).push(strip(t.name));
+        }
+        return { curated: [...new Set(curated)], generated: [...new Set(generated)] };
+    }
     reveal(service) {
         if (this.revealed.has(service))
             return false;

package/dist/tools/drive.js

@@ -129,8 +129,8 @@ export function registerDriveTools(server) {
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
             query: z.string().describe('A plain keyword (full-text search) or Drive query syntax, e.g. "name contains \'MoU\'"'),
-            maxResults: z.number().min(1).max(100).default(20).optional()
-                .describe('Max results to return (default: 20)'),
+            maxResults: z.number().min(1).max(100).default(10).optional()
+                .describe('Max results to return (default: 10, max: 100)'),
             driveId: z.string().optional().describe('Optional shared drive ID'),
         },
     }, async ({ account, query, maxResults, driveId }) => {
@@ -139,7 +139,7 @@ export function registerDriveTools(server) {
             const drive = driveClient({ version: 'v3', auth });
             const params = {
                 q: normalizeDriveQuery(query),
-                pageSize: maxResults ?? 20,
+                pageSize: maxResults ?? 10,
                 fields: 'files(id,name,mimeType,modifiedTime,webViewLink,size,parents,driveId)',
                 supportsAllDrives: true,
                 includeItemsFromAllDrives: true,

package/dist/tools/gmail.d.ts

@@ -1,7 +1,7 @@
 import type { ToolRegistry } from '../registry.js';
 import type { Account } from '../accounts.js';
 import { type ComposeAttachment } from './gmail-mime.js';
-import type { GmailMessageFull } from '../types.js';
+import type { GmailMessageHeader, GmailMessageFull } from '../types.js';
 /** Re: prefix unless the subject already carries one (case-insensitive, after
  * trimming); never double-prefix. */
 export declare function deriveReplySubject(sourceSubject: string): string;
@@ -33,5 +33,14 @@ export declare function parseMessage(msg: any, bodyCap?: number, opts?: {
  * ordered per-id entries followed by a trailing counts summary.
  */
 export declare function readBatch(gmail: any, account: Account, ids: string[], full: boolean, rawHtml: boolean): Promise<any[]>;
+/** Compact gmail_search row: just the pick-one-message selection signal, with
+ * the snippet flattened to one bounded line. Pure. */
+export declare function compactMessageRow(m: GmailMessageHeader): {
+    id: string;
+    from: string;
+    subject: string;
+    date: string;
+    snippet: string;
+};
 export declare function registerGmailTools(server: ToolRegistry): void;
 export {};

package/dist/tools/gmail.js

@@ -423,16 +423,30 @@ export async function readBatch(gmail, account, ids, full, rawHtml) {
     const summary = { counts: { ok, failed }, ...(truncatedAny ? { truncated: true } : {}) };
     return [...entries, summary];
 }
+/** Compact gmail_search row: just the pick-one-message selection signal, with
+ * the snippet flattened to one bounded line. Pure. */
+export function compactMessageRow(m) {
+    const snippet = m.snippet.replace(/\s+/g, ' ').trim();
+    return {
+        id: m.id,
+        from: m.from,
+        subject: m.subject,
+        date: m.date,
+        snippet: snippet.length > 120 ? `${snippet.slice(0, 119)}…` : snippet,
+    };
+}
 export function registerGmailTools(server) {
     server.registerTool('gmail_search', {
-        description: 'Search messages in a Gmail account',
+        description: 'Search messages in a Gmail account. Returns compact rows (id, from, subject, date, snippet); ' +
+            'pass full=true for threadId, to, labelIds and the untruncated snippet.',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
             query: z.string().describe('Gmail search syntax, e.g. "from:monaam is:unread"'),
             maxResults: z.number().min(1).max(100).default(20).optional()
                 .describe('Max results to return (default: 20, max: 100)'),
+            full: coerceBoolean.optional().describe('Return the full row shape instead of the compact default'),
         },
-    }, async ({ account, query, maxResults }) => {
+    }, async ({ account, query, maxResults, full }) => {
         try {
             const auth = await getClient(account);
             const gmail = gmailClient({ version: 'v1', auth });
@@ -466,8 +480,12 @@ export function registerGmailTools(server) {
                     });
                 }
             }
+            // Search is a pick-one-message step ~always followed by gmail_read;
+            // the compact row is the selection signal, the rest was measured burn
+            // (p90 14.4k chars per call). full=true restores the pre-6.0 shape.
+            const rows = full === true ? results : results.map(compactMessageRow);
             return {
-                content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
+                content: [{ type: 'text', text: JSON.stringify(rows, null, 2) }],
             };
         }
         catch (error) {

package/dist/tools/google-api.js

@@ -117,7 +117,8 @@ export function registerEscapeTools(registry, policy, deps = {}) {
     registry.registerMeta('google_api_call', {
         description: 'Invoke any Google Workspace REST method by Discovery id (escape hatch for operations without a ' +
             'dedicated tool). Find methods with google_api_search first. Subject to the same write-control ' +
-            'policy as named tools. Returns JSON only — for binary/file content (media downloads, ' +
+            'policy as named tools. On reads, pass a `fields` query param (Google partial response) to keep ' +
+            'the payload small. Returns JSON only — for binary/file content (media downloads, ' +
             'drive.files.export) use drive_download / drive_export instead.',
         inputSchema: {
             account: accountEnum.describe('Google account alias (omit for the default account)'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-google-multi",
-  "version": "6.0.0-alpha.20",
+  "version": "6.0.0-alpha.22",
   "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",