mcp-google-multi 5.1.0-alpha.2 → 5.1.0-alpha.4

package/README.md

@@ -72,6 +72,7 @@ Now the only thing on disk is the **encrypted** token store. Pass the token via
 | `GOOGLE_TOOLSETS` | — | `all` (default) or a CSV filter of: `gmail`, `drive`, `calendar`, `sheets`, `docs`, `contacts`, `searchconsole`, `tasks`, `meet`, `forms`, `chat`, `admin` |
 | `TOKEN_STORE_PATH` | — | override the encrypted token dir (default: `~/.config/mcp-google-multi/tokens`) |
 | `DISCOVERY_CACHE_PATH` | — | override the Discovery-doc cache dir (default: `~/.config/mcp-google-multi/discovery`) |
+| `GOOGLE_TRIM` | — | `off` (or `0`/`false`/`no`) disables compact JSON serialization of tool responses |
 
 Inspect the resolved setup any time: `mcp-google-multi config check`.
 
@@ -81,12 +82,34 @@ The server does **not** dump ~170 tool schemas into your model's context. At boo
 
 Hidden is a listing concept, not a security boundary: operational tools stay callable at all times (existing prompts that call tools directly keep working), and write-control + OAuth scopes remain the real enforcement. Use `GOOGLE_TOOLSETS` to switch entire services off — it is a filter only: listing `forms`/`chat`/`admin` does not enable them without their `GOOGLE_OPTIONAL_SCOPES` / `GOOGLE_ADMIN_ACCOUNTS` gates.
 
+## Multi-account: fan out one call across accounts
+
+Every read tool's `account` argument also accepts `"*"` (all configured accounts) or a CSV subset (`"work,personal"`). The server runs the call once per account (bounded concurrency) and returns per-account results — one account failing never hides the others:
+
+```jsonc
+{ "results": [
+    { "account": "work", "ok": true, "data": { /* … */ } },
+    { "account": "personal", "ok": false, "error": { "error": "auth_required", /* … */ } }
+  ],
+  "partial": true }
+```
+
+Fan-out is **read-only by design** (write tools take exactly one account), and the three read tools that save files to disk (`drive_download`, `drive_export`, `gmail_download_attachment`) are excluded so parallel accounts can't clobber the same path. `account_list` shows what's configured: alias, email, token health (`ok` / `expired_refreshable` / `needs_reauth` / `missing` / `decrypt_error`), and granted-vs-configured scopes — without ever touching token values.
+
 ## Escape hatch: any Workspace REST method
 
 Two eager tools cover everything the curated set doesn't: `google_api_search` finds any method in Google's API Discovery index (including APIs with no dedicated tools here, like Slides), and `google_api_call` invokes a method by its Discovery id (`drive.revisions.list`, `slides.presentations.create`, …) with path/query params and a JSON body. Calls run through your account's OAuth client and the **same write-control policy** as named tools: the read/create/update/delete class is derived from the method's HTTP verb and name (POST deletes like `batchDelete`/`clear` count as deletes), and policy globs/`GOOGLE_TOOLSETS` match the same service names as named tools (`people` counts as `contacts`, `admin_*` as `admin`; `slides`/`driveactivity`/`drivelabels`/`groupssettings` have no named service and are always available).
 
 Discovery documents are fetched from Google on first use and cached on disk for 7 days (`DISCOVERY_CACHE_PATH`, default `~/.config/mcp-google-multi/discovery`); a stale cache is used when offline.
 
+## Lean responses by default
+
+Tool responses are serialized compactly (no pretty-print token tax; set `GOOGLE_TRIM=off` to restore pretty JSON), and the fat readers ship sensible caps with per-call escape valves. The caps are per-call controls (`full` / `maxChars`) and are NOT affected by `GOOGLE_TRIM`:
+
+- `drive_read` returns up to `maxChars` characters (default 100k) with `truncated`/`totalChars`/`offset` for paging — this also bounds Google Doc exports, which can reach 10MB. (Non-Google-native files over 2MB are still rejected with `too_large`, not paged.)
+- `gmail_read` / `gmail_read_thread` cap each message body at 50k chars (`bodyTruncated` + `bodyTotalChars` flags); pass `full: true` for the whole body.
+- `calendar_list_events` / `calendar_list_instances` trim descriptions to ~300 chars and drop empty/audit fields (`created`/`updated`) in list view; `calendar_get_event` always returns the full event.
+
 ## Write-control (deny-by-default)
 
 Reads are never gated. **Every create/update/delete is off until you opt in** — pick a profile:

package/dist/accounts.js

@@ -40,6 +40,9 @@ function parseAccounts() {
         if (!/^[a-zA-Z0-9_-]+$/.test(alias)) {
             throw new Error(`Invalid alias "${alias}". Allowed characters: letters, digits, underscore, hyphen.`);
         }
+        if (aliases.includes(alias)) {
+            throw new Error(`Duplicate alias "${alias}" in GOOGLE_ACCOUNTS. Each alias must be unique.`);
+        }
         aliases.push(alias);
         configs[alias] = {
             email,

package/dist/fanout.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export declare const CSV_RE: RegExp;
+export declare function fanoutAccountField(description: string): z.ZodType;
+export type AccountSelector = {
+    ok: true;
+    fanout: boolean;
+    aliases: string[];
+} | {
+    ok: false;
+    invalid: string[];
+};
+export declare function parseAccountSelector(value: string, accounts?: readonly string[]): AccountSelector;
+export declare function invalidAccountsResult(invalid: string[], accounts?: readonly string[]): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: true;
+};
+export interface FanoutEntry {
+    account: string;
+    ok: boolean;
+    data?: unknown;
+    error?: unknown;
+}
+export declare function runFanout(handler: (...a: unknown[]) => unknown, args: unknown[], aliases: string[]): Promise<{
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+    isError?: true;
+}>;

package/dist/fanout.js

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+import { ACCOUNTS } from './accounts.js';
+export const CSV_RE = /^[a-zA-Z0-9_-]+(\s*,\s*[a-zA-Z0-9_-]+)+$/;
+const FANOUT_CONCURRENCY = 5;
+export function fanoutAccountField(description) {
+    const csvExample = ACCOUNTS.length > 1 ? `; or a CSV subset like "${ACCOUNTS.slice(0, 2).join(',')}"` : '';
+    return z
+        .union([z.enum([...ACCOUNTS, '*']), z.string().regex(CSV_RE)])
+        .describe(`${description}; "*" = all accounts${csvExample}`);
+}
+export function parseAccountSelector(value, accounts = ACCOUNTS) {
+    if (value === '*')
+        return { ok: true, fanout: true, aliases: [...accounts] };
+    if (!value.includes(','))
+        return { ok: true, fanout: false, aliases: [value] };
+    const seen = new Set();
+    const aliases = [];
+    const invalid = [];
+    for (const token of value.split(',').map((t) => t.trim()).filter(Boolean)) {
+        if (!accounts.includes(token)) {
+            invalid.push(token);
+        }
+        else if (!seen.has(token)) {
+            seen.add(token);
+            aliases.push(token);
+        }
+    }
+    if (invalid.length > 0)
+        return { ok: false, invalid };
+    return { ok: true, fanout: aliases.length > 1, aliases };
+}
+export function invalidAccountsResult(invalid, accounts = ACCOUNTS) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    error: 'validation_error',
+                    message: `Unknown account alias(es): ${invalid.join(', ')}.`,
+                    hint: `Valid aliases: ${accounts.join(', ')}; or "*" for all accounts.`,
+                    retriable: false,
+                }),
+            },
+        ],
+        isError: true,
+    };
+}
+function parsePayload(result) {
+    const text = result?.content?.[0]?.text;
+    if (typeof text !== 'string')
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+export async function runFanout(handler, args, aliases) {
+    const results = new Array(aliases.length);
+    let next = 0;
+    const worker = async () => {
+        while (next < aliases.length) {
+            const i = next++;
+            const account = aliases[i];
+            try {
+                const res = (await handler({ ...args[0], account }, ...args.slice(1)));
+                const payload = parsePayload(res);
+                results[i] = res?.isError ? { account, ok: false, error: payload } : { account, ok: true, data: payload };
+            }
+            catch (err) {
+                results[i] = {
+                    account,
+                    ok: false,
+                    error: { error: 'internal', message: err.message, retriable: false, account },
+                };
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(FANOUT_CONCURRENCY, aliases.length) }, () => worker()));
+    const failed = results.filter((r) => !r.ok).length;
+    const body = { results, partial: failed > 0 };
+    const out = { content: [{ type: 'text', text: JSON.stringify(body) }] };
+    return failed === results.length ? { ...out, isError: true } : out;
+}

package/dist/index.js

@@ -21,6 +21,7 @@ import { getOptionalBundles, getAdminAccounts } from './auth.js';
 import { ToolRegistry } from './registry.js';
 import { registerDiscoverTools } from './discover.js';
 import { registerEscapeTools } from './tools/google-api.js';
+import { registerAccountTools } from './tools/accounts-tool.js';
 import { getToolsets, toolsetEnabled } from './toolsets.js';
 import { resolvePolicy, isAllowed, describePolicy } from './write-control.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -69,6 +70,7 @@ function buildRegistry(server, policy) {
     }
     registerDiscoverTools(registry, policy);
     registerEscapeTools(registry, policy);
+    registerAccountTools(registry);
     return registry;
 }
 async function main() {

package/dist/registry.d.ts

@@ -24,6 +24,7 @@ export declare class ToolRegistry {
     readonly registerTool: McpServer['registerTool'];
     private readonly revealed;
     private readonly jsonSchemaCache;
+    private readonly compactOutput;
     private registeringMeta;
     constructor(server: McpServer, policy: Policy);
     registerMeta: McpServer['registerTool'];

package/dist/registry.js

@@ -1,12 +1,20 @@
 import { ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
 import { isAllowed, writeDisabledResult } from './write-control.js';
+import { compactResult, trimEnabled } from './trim.js';
+import { fanoutAccountField, invalidAccountsResult, parseAccountSelector, runFanout } from './fanout.js';
 const CUD_OVERRIDES = {
     drive_untrash: 'update',
 };
 const SERVICE_OVERRIDES = {
     reports_activities_list: 'admin',
 };
+// Read tools that write to the local filesystem: fanning the same savePath
+// across accounts would clobber (last write wins).
+const FANOUT_EXCLUDE = new Set(['gmail_download_attachment', 'drive_download', 'drive_export']);
+function isAccountEnum(field) {
+    return field?._zod?.def?.type === 'enum';
+}
 const DELETE_VERB = /(^|_)(delete|remove|trash|clear|empty)(_|$)/;
 const CREATE_VERB = /(^|_)(create|add|insert|send|upload|copy|import|append|submit|duplicate|share|quick)(_|$)/;
 const UPDATE_VERB = /(^|_)(update|patch|modify|set|move|write|format|merge|unmerge|sort|replace|resize|publish|resolve)(_|$)/;
@@ -28,6 +36,7 @@ export class ToolRegistry {
     registerTool;
     revealed = new Set();
     jsonSchemaCache = new Map();
+    compactOutput = trimEnabled();
     registeringMeta = false;
     constructor(server, policy) {
         this.server = server;
@@ -40,21 +49,41 @@ export class ToolRegistry {
                 destructiveHint: cud === 'delete' || cud === 'update',
                 ...config.annotations,
             };
+            // Fan-out is read-only and never applies to meta tools: google_api_call's
+            // registry cud is "read" but it executes arbitrary writes.
+            let inputShape = config.inputSchema ?? {};
+            let baseHandler = handler;
+            if (cud === 'read' && !this.registeringMeta && !FANOUT_EXCLUDE.has(name) && isAccountEnum(inputShape.account)) {
+                const description = inputShape.account.description ?? 'Google account alias';
+                inputShape = { ...inputShape, account: fanoutAccountField(description) };
+                baseHandler = async (...args) => {
+                    const first = args[0];
+                    const parsed = parseAccountSelector(typeof first?.account === 'string' ? first.account : '');
+                    if (!parsed.ok)
+                        return invalidAccountsResult(parsed.invalid);
+                    if (!parsed.fanout)
+                        return handler({ ...first, account: parsed.aliases[0] }, ...args.slice(1));
+                    return runFanout(handler, args, parsed.aliases);
+                };
+            }
             this.tools.push({
                 name,
                 service,
                 cud,
                 description: config.description ?? '',
-                inputShape: config.inputSchema ?? {},
+                inputShape,
                 annotations,
                 meta: this.registeringMeta,
             });
             const guarded = cud === 'read'
-                ? handler
+                ? baseHandler
                 : (...args) => isAllowed({ name, service, cud }, policy)
-                    ? handler(...args)
+                    ? baseHandler(...args)
                     : writeDisabledResult({ name, service, cud }, policy);
-            return server.registerTool(name, { ...config, annotations }, guarded);
+            const finalHandler = this.compactOutput
+                ? async (...args) => compactResult(await guarded(...args))
+                : guarded;
+            return server.registerTool(name, { ...config, inputSchema: inputShape, annotations }, finalHandler);
         });
     }
     registerMeta = ((name, config, handler) => {

package/dist/tools/accounts-tool.d.ts

@@ -0,0 +1,29 @@
+import type { ToolRegistry } from '../registry.js';
+export interface AccountHealthDeps {
+    hasToken: (alias: string) => boolean;
+    readToken: (alias: string) => {
+        expiry_date?: number;
+        refresh_token?: string;
+        scope?: string;
+    } | null;
+    fileExists: (p: string) => boolean;
+    now: () => number;
+}
+export type TokenStatus = 'ok' | 'expired_refreshable' | 'needs_reauth' | 'missing' | 'decrypt_error';
+export interface AccountHealth {
+    alias: string;
+    email: string;
+    admin: boolean;
+    token: {
+        status: TokenStatus;
+        expiryDate?: string;
+        hint?: string;
+    };
+    scopes: {
+        configured: number;
+        granted: number;
+        missing: string[];
+    };
+}
+export declare function deriveAccountHealth(alias: string, deps?: AccountHealthDeps): AccountHealth;
+export declare function registerAccountTools(registry: ToolRegistry, deps?: AccountHealthDeps): void;

package/dist/tools/accounts-tool.js

@@ -0,0 +1,80 @@
+import * as fs from 'node:fs';
+import { ACCOUNTS, ACCOUNT_CONFIG } from '../accounts.js';
+import { getAdminAccounts, resolveScopesForAccount } from '../auth.js';
+import { hasToken, readToken } from '../token-store.js';
+const DEFAULT_DEPS = {
+    hasToken,
+    readToken,
+    fileExists: fs.existsSync,
+    now: Date.now,
+};
+export function deriveAccountHealth(alias, deps = DEFAULT_DEPS) {
+    const config = ACCOUNT_CONFIG[alias];
+    const admin = getAdminAccounts().includes(alias);
+    const configured = resolveScopesForAccount(alias);
+    const base = { alias, email: config.email, admin };
+    const noScopes = { configured: configured.length, granted: 0, missing: configured };
+    if (!deps.hasToken(alias)) {
+        const legacy = deps.fileExists(config.tokenPath);
+        return {
+            ...base,
+            token: {
+                status: 'missing',
+                hint: legacy
+                    ? 'Plaintext token.json found — run: npx mcp-google-multi migrate-tokens'
+                    : `Run: npx mcp-google-multi auth --account ${alias}`,
+            },
+            scopes: noScopes,
+        };
+    }
+    let token;
+    try {
+        token = deps.readToken(alias);
+    }
+    catch {
+        return {
+            ...base,
+            token: { status: 'decrypt_error', hint: 'Wrong MASTER_KEY or corrupt token file — re-auth or restore the key.' },
+            scopes: noScopes,
+        };
+    }
+    const granted = typeof token?.scope === 'string' ? token.scope.split(' ').filter(Boolean) : [];
+    const missing = configured.filter((s) => !granted.includes(s));
+    const expiry = typeof token?.expiry_date === 'number' ? token.expiry_date : undefined;
+    const refreshable = typeof token?.refresh_token === 'string' && token.refresh_token.length > 0;
+    let status;
+    if (expiry !== undefined && expiry > deps.now())
+        status = 'ok';
+    else if (refreshable)
+        status = 'expired_refreshable';
+    else
+        status = 'needs_reauth';
+    return {
+        ...base,
+        token: {
+            status,
+            expiryDate: expiry !== undefined ? new Date(expiry).toISOString() : undefined,
+            hint: status === 'needs_reauth'
+                ? `Run: npx mcp-google-multi auth --account ${alias}`
+                : missing.length > 0
+                    ? 'Re-auth to grant the missing scopes'
+                    : undefined,
+        },
+        scopes: { configured: configured.length, granted: granted.length, missing },
+    };
+}
+export function registerAccountTools(registry, deps = DEFAULT_DEPS) {
+    registry.registerMeta('account_list', {
+        description: 'List the configured Google accounts: alias, email, admin flag, token health ' +
+            '(ok / expired_refreshable / needs_reauth / missing / decrypt_error), and granted vs configured scopes. ' +
+            'Use this to see which account aliases are available and healthy.',
+        inputSchema: {},
+    }, async () => ({
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({ accounts: ACCOUNTS.map((alias) => deriveAccountHealth(alias, deps)) }),
+            },
+        ],
+    }));
+}

package/dist/tools/calendar.d.ts

@@ -1,2 +1,22 @@
 import type { ToolRegistry } from '../registry.js';
 export declare function registerCalendarTools(server: ToolRegistry): void;
+export declare function formatEvent(event: any, opts?: {
+    full?: boolean;
+}): {
+    id: any;
+    summary: any;
+    description: string;
+    location: any;
+    start: any;
+    end: any;
+    status: any;
+    htmlLink: any;
+    organizer: any;
+    attendees: any;
+    recurringEventId: any;
+    hangoutLink: any;
+    created: any;
+    updated: any;
+} | {
+    [k: string]: any;
+};

package/dist/tools/calendar.js

@@ -4,6 +4,7 @@ import { google } from 'googleapis';
 import { ACCOUNTS } from '../accounts.js';
 import { getClient } from '../client.js';
 import { handleGoogleApiError } from './_errors.js';
+import { sliceClean } from '../trim.js';
 const accountEnum = z.enum(ACCOUNTS);
 export function registerCalendarTools(server) {
     server.registerTool('calendar_list_calendars', {
@@ -33,7 +34,7 @@ export function registerCalendarTools(server) {
         }
     });
     server.registerTool('calendar_list_events', {
-        description: 'List events from a Google Calendar',
+        description: 'List events from a Google Calendar (trimmed view: descriptions capped, created/updated and empty fields omitted — use calendar_get_event for a full event)',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
             calendarId: z.string().default('primary').optional()
@@ -66,7 +67,7 @@ export function registerCalendarTools(server) {
                 params.timeMin = new Date().toISOString();
             }
             const res = await cal.events.list(params);
-            const events = (res.data.items ?? []).map(formatEvent);
+            const events = (res.data.items ?? []).map((e) => formatEvent(e, { full: false }));
             return {
                 content: [{ type: 'text', text: JSON.stringify(events, null, 2) }],
             };
@@ -288,7 +289,7 @@ export function registerCalendarTools(server) {
         }
     });
     server.registerTool('calendar_list_instances', {
-        description: 'List all occurrences of a recurring calendar event',
+        description: 'List all occurrences of a recurring calendar event (trimmed view like calendar_list_events — use calendar_get_event for a full event)',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
             calendarId: z.string().default('primary').optional()
@@ -310,7 +311,7 @@ export function registerCalendarTools(server) {
                 timeMax,
                 maxResults: maxResults ?? 25,
             });
-            const events = (res.data.items ?? []).map(formatEvent);
+            const events = (res.data.items ?? []).map((e) => formatEvent(e, { full: false }));
             return {
                 content: [{ type: 'text', text: JSON.stringify(events, null, 2) }],
             };
@@ -376,11 +377,19 @@ export function registerCalendarTools(server) {
         }
     });
 }
-function formatEvent(event) {
-    return {
+const LIST_DESCRIPTION_CAP = 300;
+const TRUNCATION_MARKER = '… [truncated, use calendar_get_event]';
+export function formatEvent(event, opts = {}) {
+    const full = opts.full ?? true;
+    const description = event.description ?? '';
+    // Slack margin: truncating a 301-char description to 300 + 37-char marker would GROW it.
+    const cappedDescription = full || description.length <= LIST_DESCRIPTION_CAP + TRUNCATION_MARKER.length
+        ? description
+        : `${sliceClean(description, LIST_DESCRIPTION_CAP)}${TRUNCATION_MARKER}`;
+    const base = {
         id: event.id,
         summary: event.summary ?? '',
-        description: event.description ?? '',
+        description: cappedDescription,
         location: event.location ?? '',
         start: event.start?.dateTime ?? event.start?.date ?? '',
         end: event.end?.dateTime ?? event.end?.date ?? '',
@@ -391,9 +400,14 @@ function formatEvent(event) {
             email: a.email,
             responseStatus: a.responseStatus,
         })),
-        created: event.created,
-        updated: event.updated,
+        recurringEventId: event.recurringEventId,
+        hangoutLink: event.hangoutLink,
+        created: full ? event.created : undefined,
+        updated: full ? event.updated : undefined,
     };
+    if (full)
+        return base;
+    return Object.fromEntries(Object.entries(base).filter(([, v]) => v !== undefined && v !== '' && !(Array.isArray(v) && v.length === 0)));
 }
 function handleCalendarError(error, account) {
     return handleGoogleApiError(error, account);

package/dist/tools/drive.js

@@ -4,6 +4,7 @@ import { google } from 'googleapis';
 import { ACCOUNTS } from '../accounts.js';
 import { getClient } from '../client.js';
 import { handleGoogleApiError } from './_errors.js';
+import { capText } from '../trim.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { pipeline } from 'node:stream/promises';
@@ -59,12 +60,16 @@ export function registerDriveTools(server) {
         }
     });
     server.registerTool('drive_read', {
-        description: 'Read the content of a Google Drive file',
+        description: 'Read the content of a Google Drive file (returns up to maxChars characters per call; non-Google-native files over 2MB return too_large)',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
             fileId: z.string().describe('Google Drive file ID'),
+            maxChars: z.number().min(1).max(2_000_000).default(100_000).optional()
+                .describe('Max characters of content to return (default: 100000)'),
+            offset: z.number().min(0).default(0).optional()
+                .describe('Character offset to continue a truncated read (Google Docs/Sheets/Slides exports page fine; plain files >2MB are rejected, not paged)'),
         },
-    }, async ({ account, fileId }) => {
+    }, async ({ account, fileId, maxChars, offset }) => {
         try {
             const auth = await getClient(account);
             const drive = google.drive({ version: 'v3', auth });
@@ -74,11 +79,9 @@ export function registerDriveTools(server) {
                 supportsAllDrives: true,
             });
             const { name, mimeType, size, webViewLink } = meta.data;
-            if (mimeType && GOOGLE_WORKSPACE_TYPES.has(mimeType)) {
-                const exported = await drive.files.export({
-                    fileId,
-                    mimeType: 'text/plain',
-                });
+            const respond = (raw) => {
+                const from = offset ?? 0;
+                const capped = capText(raw, maxChars ?? 100_000, from);
                 return {
                     content: [{
                             type: 'text',
@@ -86,10 +89,20 @@ export function registerDriveTools(server) {
                                 id: fileId,
                                 name,
                                 mimeType,
-                                content: String(exported.data),
+                                content: capped.text,
+                                ...(capped.truncated || from > 0
+                                    ? { truncated: capped.truncated, totalChars: capped.totalChars, offset: from }
+                                    : {}),
                             }, null, 2),
                         }],
                 };
+            };
+            if (mimeType && GOOGLE_WORKSPACE_TYPES.has(mimeType)) {
+                const exported = await drive.files.export({
+                    fileId,
+                    mimeType: 'text/plain',
+                });
+                return respond(String(exported.data));
             }
             if (mimeType === 'application/pdf') {
                 return {
@@ -122,17 +135,7 @@ export function registerDriveTools(server) {
             }
             if (mimeType?.startsWith('text/')) {
                 const downloaded = await drive.files.get({ fileId, alt: 'media', supportsAllDrives: true }, { responseType: 'text' });
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                id: fileId,
-                                name,
-                                mimeType,
-                                content: String(downloaded.data),
-                            }, null, 2),
-                        }],
-                };
+                return respond(String(downloaded.data));
             }
             return {
                 content: [{

package/dist/tools/gmail.d.ts

@@ -1,2 +1,4 @@
 import type { ToolRegistry } from '../registry.js';
+import type { GmailMessageFull } from '../types.js';
+export declare function parseMessage(msg: any, bodyCap?: number): GmailMessageFull;
 export declare function registerGmailTools(server: ToolRegistry): void;

package/dist/tools/gmail.js

@@ -5,6 +5,7 @@ import { ACCOUNTS } from '../accounts.js';
 import { getClient } from '../client.js';
 import { handleGoogleApiError } from './_errors.js';
 import { buildMultipartAlternative, encodeAddressHeader, encodeHeaderValue, normalizeBodyLineEndings } from './gmail-mime.js';
+import { sliceClean } from '../trim.js';
 import * as path from 'path';
 import * as fs from 'fs';
 const accountEnum = z.enum(ACCOUNTS);
@@ -52,8 +53,11 @@ function getAttachments(payload) {
     }
     return attachments;
 }
-function parseMessage(msg) {
+const BODY_CAP_CHARS = 50_000;
+export function parseMessage(msg, bodyCap) {
     const headers = msg.payload?.headers ?? [];
+    const body = decodeBody(msg.payload);
+    const capped = bodyCap !== undefined && body.length > bodyCap;
     return {
         id: msg.id ?? '',
         threadId: msg.threadId ?? '',
@@ -62,7 +66,8 @@ function parseMessage(msg) {
         to: getHeader(headers, 'To'),
         cc: getHeader(headers, 'Cc'),
         date: getHeader(headers, 'Date'),
-        body: decodeBody(msg.payload),
+        body: capped ? sliceClean(body, bodyCap) : body,
+        ...(capped ? { bodyTruncated: true, bodyTotalChars: body.length } : {}),
         attachments: getAttachments(msg.payload),
     };
 }
@@ -111,12 +116,13 @@ export function registerGmailTools(server) {
         }
     });
     server.registerTool('gmail_read', {
-        description: 'Read a full Gmail message by ID',
+        description: 'Read a full Gmail message by ID (body capped at 50k chars unless full=true)',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
             messageId: z.string().describe('Gmail message ID'),
+            full: coerceBoolean.optional().describe('Return the entire body without the character cap'),
         },
-    }, async ({ account, messageId }) => {
+    }, async ({ account, messageId, full }) => {
         try {
             const auth = await getClient(account);
             const gmail = google.gmail({ version: 'v1', auth });
@@ -125,7 +131,7 @@ export function registerGmailTools(server) {
                 id: messageId,
                 format: 'full',
             });
-            const result = parseMessage(res.data);
+            const result = parseMessage(res.data, full ? undefined : BODY_CAP_CHARS);
             return {
                 content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
             };
@@ -135,12 +141,13 @@ export function registerGmailTools(server) {
         }
     });
     server.registerTool('gmail_read_thread', {
-        description: 'Read all messages in a Gmail thread',
+        description: 'Read all messages in a Gmail thread (bodies capped at 50k chars each unless full=true)',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
             threadId: z.string().describe('Gmail thread ID'),
+            full: coerceBoolean.optional().describe('Return entire bodies without the character cap'),
         },
-    }, async ({ account, threadId }) => {
+    }, async ({ account, threadId, full }) => {
         try {
             const auth = await getClient(account);
             const gmail = google.gmail({ version: 'v1', auth });
@@ -149,7 +156,7 @@ export function registerGmailTools(server) {
                 id: threadId,
                 format: 'full',
             });
-            const messages = (res.data.messages ?? []).map(parseMessage);
+            const messages = (res.data.messages ?? []).map((m) => parseMessage(m, full ? undefined : BODY_CAP_CHARS));
             return {
                 content: [{ type: 'text', text: JSON.stringify(messages, null, 2) }],
             };

package/dist/trim.d.ts

@@ -0,0 +1,16 @@
+export declare function trimEnabled(env?: NodeJS.ProcessEnv): boolean;
+export interface CappedText {
+    text: string;
+    truncated: boolean;
+    totalChars: number;
+}
+export declare function capText(text: string, maxChars: number, offset?: number): CappedText;
+export declare function sliceClean(text: string, max: number): string;
+interface ToolResult {
+    content?: {
+        type?: string;
+        text?: string;
+    }[];
+}
+export declare function compactResult<T extends ToolResult>(result: T): T;
+export {};

package/dist/trim.js

@@ -0,0 +1,29 @@
+export function trimEnabled(env = process.env) {
+    return !/^(0|false|off|no)$/i.test((env.GOOGLE_TRIM ?? '').trim());
+}
+export function capText(text, maxChars, offset = 0) {
+    const slice = text.slice(offset, offset + maxChars);
+    return { text: slice, truncated: offset + slice.length < text.length, totalChars: text.length };
+}
+// For permanent (non-paging) caps: dropping a trailing lone high surrogate keeps
+// the truncated string well-formed Unicode instead of ending in mojibake.
+export function sliceClean(text, max) {
+    const sliced = text.slice(0, max);
+    return /[\uD800-\uDBFF]$/.test(sliced) ? sliced.slice(0, -1) : sliced;
+}
+// Pretty-printed JSON costs ~20-30% extra tokens; re-serialize compactly.
+export function compactResult(result) {
+    if (!result || !Array.isArray(result.content))
+        return result;
+    for (const item of result.content) {
+        if (item?.type === 'text' && typeof item.text === 'string' && /^[\s]*[[{]/.test(item.text)) {
+            try {
+                item.text = JSON.stringify(JSON.parse(item.text));
+            }
+            catch {
+                // not JSON — leave untouched
+            }
+        }
+    }
+    return result;
+}

package/dist/types.d.ts

@@ -27,6 +27,8 @@ export interface GmailMessageFull {
     cc: string;
     date: string;
     body: string;
+    bodyTruncated?: boolean;
+    bodyTotalChars?: number;
     attachments: GmailAttachment[];
 }
 export interface DriveFile {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-google-multi",
-  "version": "5.1.0-alpha.2",
+  "version": "5.1.0-alpha.4",
   "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",