mcp-google-multi 6.0.0-beta.4 → 6.0.0

package/dist/tools/generated/gmail.js

@@ -18,20 +18,6 @@ export function registerGmailGeneratedTools(registry, deps = {}) {
         ["https://mail.google.com/", "https://www.googleapis.com/auth/gmail.metadata", "https://www.googleapis.com/auth/gmail.modify", "https://www.googleapis.com/auth/gmail.readonly"],
         ["https://mail.google.com/"],
     ];
-    registerGeneratedTool(registry, {
-        name: "gmail_users_drafts_delete",
-        cud: "delete",
-        description: "Immediately and permanently deletes the specified draft. Does not simply trash it. For more information, see [Create and send draft emails](https://developers.g",
-        method: { id: "gmail.users.drafts.delete", httpMethod: "DELETE", path: "gmail/v1/users/{userId}/drafts/{id}", baseUrl: "https://gmail.googleapis.com/", requiredParams: ["userId", "id"], scopes: S_gmail_v1[0] },
-        params: [{ "field": "id", "api": "id", "location": "path" }, { "field": "userId", "api": "userId", "location": "path" }, { "field": "fields", "api": "fields", "location": "query" }],
-        hasBody: false,
-        shape: {
-            account: accountField(() => registry.accountAliases()),
-            id: z.string().min(1).describe("The ID of the draft to delete."),
-            userId: z.string().min(1).describe("The user's email address. The special value `me` can be used to indicate the authenticated user."),
-            fields: z.string().optional().describe('Response field mask.'),
-        },
-    }, deps);
     registerGeneratedTool(registry, {
         name: "gmail_users_drafts_update",
         cud: "update",

package/dist/tools/generated/method-map.js

@@ -550,7 +550,6 @@ export const GENERATED_METHOD_TOOLS = {
     "forms.forms.watches.create": "forms_forms_watches_create",
     "forms.forms.watches.delete": "forms_forms_watches_delete",
     "forms.forms.watches.renew": "forms_forms_watches_renew",
-    "gmail.users.drafts.delete": "gmail_users_drafts_delete",
     "gmail.users.drafts.update": "gmail_users_drafts_update",
     "gmail.users.labels.get": "gmail_users_labels_get",
     "gmail.users.labels.patch": "gmail_users_labels_patch",
@@ -818,6 +817,7 @@ export const CURATED_METHOD_IDS = [
     "forms.forms.setPublishSettings",
     "forms.forms.watches.list",
     "gmail.users.drafts.create",
+    "gmail.users.drafts.delete",
     "gmail.users.drafts.get",
     "gmail.users.drafts.list",
     "gmail.users.drafts.send",

package/dist/tools/gmail.d.ts

@@ -33,7 +33,7 @@ export declare function parseMessage(msg: any, bodyCap?: number, opts?: {
  * is rethrown so the caller maps it to a whole-call isError. Returns the
  * 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[]>;
+export declare function readBatch(gmail: any, account: Account, ids: string[], full: boolean, rawHtml: boolean, metaHeaders?: string[]): 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): {

package/dist/tools/gmail.js

@@ -17,6 +17,12 @@ import * as fs from 'fs';
 function getHeader(headers, name) {
     return headers?.find((h) => h.name?.toLowerCase() === name.toLowerCase())?.value ?? '';
 }
+function pickHeaders(headers, names) {
+    const out = {};
+    for (const name of names)
+        out[name] = getHeader(headers, name);
+    return out;
+}
 function collectTextParts(part, plain, html, topLevel = false) {
     if (!part)
         return;
@@ -176,6 +182,21 @@ export async function resolveReply(gmail, account, primaryEmail, replyToMessageI
         subject: deriveReplySubject(getHeader(headers, 'Subject')),
     };
 }
+// Gmail's after:/before: operators take epoch seconds; Date.parse accepts both
+// an ISO date and a full date-time, so one parse covers both input shapes.
+function parseEpochSeconds(value) {
+    // A date-only value is interpreted as 00:00 UTC.
+    // A date-time must include Z or an offset (+HH:MM or -HH:MM) to be unambiguous.
+    if (value.includes('T')) {
+        const hasZ = value.endsWith('Z');
+        const hasOffset = /[+-]\d{2}:\d{2}$/.test(value);
+        if (!hasZ && !hasOffset) {
+            return null;
+        }
+    }
+    const ms = Date.parse(value);
+    return Number.isNaN(ms) ? null : Math.floor(ms / 1000);
+}
 const BODY_CAP_CHARS = 50_000;
 // gmail_read_batch aggregate ceiling: bounds the summed serialized output so a
 // 100-message batch can't blow the context window (per-message bodies are capped at BODY_CAP_CHARS first).
@@ -331,13 +352,14 @@ export function parseMessage(msg, bodyCap, opts) {
  * is rethrown so the caller maps it to a whole-call isError. Returns the
  * ordered per-id entries followed by a trailing counts summary.
  */
-export async function readBatch(gmail, account, ids, full, rawHtml) {
+export async function readBatch(gmail, account, ids, full, rawHtml, metaHeaders) {
     if (ids.length === 0) {
         throw new GmailComposeError('validation_error', '`ids` must be a non-empty array of 1..100 message IDs.');
     }
     if (ids.length > 100) {
         throw new GmailComposeError('validation_error', `\`ids\` accepts at most 100 message IDs per call (got ${ids.length}).`);
     }
+    const metadataMode = metaHeaders !== undefined && metaHeaders.length > 0;
     const cap = full ? undefined : BODY_CAP_CHARS;
     const CHUNK_SIZE = 10;
     const entries = new Array(ids.length);
@@ -347,7 +369,9 @@ export async function readBatch(gmail, account, ids, full, rawHtml) {
         const slice = ids.slice(i, i + CHUNK_SIZE);
         const settled = await Promise.all(slice.map(async (id, j) => {
             try {
-                const res = await gmail.users.messages.get({ userId: 'me', id, format: 'full' });
+                const res = metadataMode
+                    ? await gmail.users.messages.get({ userId: 'me', id, format: 'metadata', metadataHeaders: metaHeaders })
+                    : await gmail.users.messages.get({ userId: 'me', id, format: 'full' });
                 return { idx: i + j, id, ok: true, data: res.data };
             }
             catch (err) {
@@ -356,7 +380,14 @@ export async function readBatch(gmail, account, ids, full, rawHtml) {
         }));
         for (const s of settled) {
             if (s.ok) {
-                entries[s.idx] = parseMessage(s.data, cap, { rawHtml });
+                entries[s.idx] = metadataMode
+                    ? {
+                        id: s.data.id ?? '',
+                        threadId: s.data.threadId ?? '',
+                        labelIds: s.data.labelIds ?? [],
+                        headers: pickHeaders(s.data.payload?.headers, metaHeaders),
+                    }
+                    : parseMessage(s.data, cap, { rawHtml });
                 ok++;
             }
             else {
@@ -374,10 +405,11 @@ export async function readBatch(gmail, account, ids, full, rawHtml) {
     }
     // Aggregate guard: walk in order accumulating serialized size; once the running
     // total would exceed the budget, cap this and every later success body so the batch never blows the context window.
+    // Metadata-mode entries carry no body, so there is nothing to cap.
     let running = 0;
     let truncatedAny = false;
     let exhausted = false;
-    for (const e of entries) {
+    for (const e of metadataMode ? [] : entries) {
         if (!e || e.error) {
             running += JSON.stringify(e ?? {}).length;
             continue;
@@ -434,27 +466,50 @@ export function registerGmailTools(server, deps = {}) {
     const registerHostFileTool = localFiles ? server.registerTool : (() => undefined);
     server.registerTool('gmail_search', {
         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.',
+            'pass full=true for threadId, to, labelIds and the untruncated snippet. ' +
+            'For a recurring "what is new" sweep, prefer gmail_list_history over polling this with since.',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
             query: z.string().describe('Gmail search syntax, e.g. "from:alice is:unread"'),
             maxResults: coerceNumber(z.number().min(1).max(100)).optional()
                 .describe('Max results to return (default: 20, max: 100)'),
             full: coerceBoolean.optional().describe('Return the full row shape instead of the compact default'),
+            since: z.string().optional()
+                .describe('Only messages on/after this ISO 8601 date (00:00 UTC) or date-time with Z or offset, added to the query as after:<epoch seconds>'),
+            until: z.string().optional()
+                .describe('Only messages before this ISO 8601 date (00:00 UTC) or date-time with Z or offset, added to the query as before:<epoch seconds>'),
+            includeSpamTrash: coerceBoolean.optional()
+                .describe('Include Spam and Trash in the search. Gmail excludes both by default, even for in:anywhere.'),
         },
-    }, async ({ account, query, maxResults, full }) => {
+    }, async ({ account, query, maxResults, full, since, until, includeSpamTrash }) => {
         try {
             // Gmail treats a blank `q` as no filter, so a caller passing an unset
             // variable got the whole mailbox back as if it had matched.
             if (query.trim() === '') {
                 return invalidParams(account, '`query` is empty, and Gmail reads an empty query as "match everything".', 'Pass a real Gmail search term such as "is:unread" or "from:someone@example.com". Returning the whole mailbox for a blank query would look like a successful search.');
             }
+            let effectiveQuery = query;
+            if (since !== undefined) {
+                const epoch = parseEpochSeconds(since);
+                if (epoch === null) {
+                    return invalidParams(account, `\`since\` is not a parsable ISO 8601 date or date-time: "${since}".`, 'Pass an ISO 8601 date (e.g. "2026-01-01") or a date-time with Z or offset (e.g. "2026-01-01T09:00:00Z").');
+                }
+                effectiveQuery = `${effectiveQuery} after:${epoch}`;
+            }
+            if (until !== undefined) {
+                const epoch = parseEpochSeconds(until);
+                if (epoch === null) {
+                    return invalidParams(account, `\`until\` is not a parsable ISO 8601 date or date-time: "${until}".`, 'Pass an ISO 8601 date (e.g. "2026-01-01") or a date-time with Z or offset (e.g. "2026-01-01T09:00:00Z").');
+                }
+                effectiveQuery = `${effectiveQuery} before:${epoch}`;
+            }
             const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             const listRes = await gmail.users.messages.list({
                 userId: 'me',
-                q: query,
+                q: effectiveQuery,
                 maxResults: maxResults ?? 20,
+                ...(includeSpamTrash !== undefined ? { includeSpamTrash } : {}),
             });
             const messages = listRes.data.messages ?? [];
             const results = [];
@@ -495,18 +550,38 @@ export function registerGmailTools(server, deps = {}) {
     });
     server.registerTool('gmail_read', {
         _meta: { 'anthropic/maxResultSizeChars': 50_000 },
-        description: 'Read a full Gmail message by ID (body capped at 50k chars unless full=true)',
+        description: 'Read a full Gmail message by ID (body capped at 50k chars unless full=true). ' +
+            'Pass `headers` for metadata mode: no body decoding, just id, threadId, labelIds and the named headers.',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
             messageId: z.string().min(1).describe('Gmail message ID'),
             full: coerceBoolean.optional().describe('Return the entire body without the character cap'),
             rawHtml: coerceBoolean.optional()
                 .describe('Return the HTML body unconverted instead of the plain-text rendering (HTML-only messages)'),
+            headers: coerceArray(z.string()).optional()
+                .describe('Header names to fetch in metadata mode instead of the full body (e.g. ["Subject", "From"])'),
         },
-    }, async ({ account, messageId, full, rawHtml }) => {
+    }, async ({ account, messageId, full, rawHtml, headers }) => {
         try {
             const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
+            if (headers !== undefined && headers.length > 0) {
+                const metaRes = await gmail.users.messages.get({
+                    userId: 'me',
+                    id: messageId,
+                    format: 'metadata',
+                    metadataHeaders: headers,
+                });
+                const metaResult = {
+                    id: metaRes.data.id ?? '',
+                    threadId: metaRes.data.threadId ?? '',
+                    labelIds: metaRes.data.labelIds ?? [],
+                    headers: pickHeaders(metaRes.data.payload?.headers, headers),
+                };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(metaResult, null, 2) }],
+                };
+            }
             const res = await gmail.users.messages.get({
                 userId: 'me',
                 id: messageId,
@@ -576,19 +651,21 @@ export function registerGmailTools(server, deps = {}) {
     server.registerTool('gmail_read_batch', {
         _meta: { 'anthropic/maxResultSizeChars': BATCH_MAX_RESULT_CHARS },
         annotations: { readOnlyHint: true, openWorldHint: true },
-        description: 'Read many Gmail messages by ID in one call, collapsing the search→read triage loop. Bodies are capped at 50k chars each (unless full=true) and the aggregate output is bounded. Returns one ordered entry per id plus a trailing counts summary; a single failed id does NOT fail the batch.',
+        description: 'Read many Gmail messages by ID in one call, collapsing the search→read triage loop. Bodies are capped at 50k chars each (unless full=true) and the aggregate output is bounded. Returns one ordered entry per id plus a trailing counts summary; a single failed id does NOT fail the batch. Pass `headers` for metadata mode: no body decoding, just id, threadId, labelIds and the named headers per entry.',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
             ids: coerceArray(z.string()).describe('Gmail message IDs to read (1..100). Comma-separated string or JSON array.'),
             full: coerceBoolean.optional().describe('Return entire bodies without the per-message 50k character cap'),
             rawHtml: coerceBoolean.optional()
                 .describe('Return HTML bodies unconverted instead of the plain-text rendering (HTML-only messages)'),
+            headers: coerceArray(z.string()).optional()
+                .describe('Header names to fetch in metadata mode instead of full bodies (e.g. ["Subject", "From"])'),
         },
-    }, async ({ account, ids, full, rawHtml }) => {
+    }, async ({ account, ids, full, rawHtml, headers }) => {
         try {
             const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
-            const result = await readBatch(gmail, account, ids ?? [], full === true, rawHtml === true);
+            const result = await readBatch(gmail, account, ids ?? [], full === true, rawHtml === true, headers);
             return {
                 content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
             };
@@ -993,6 +1070,26 @@ export function registerGmailTools(server, deps = {}) {
             return mapped ?? handleGmailError(error, account);
         }
     });
+    server.registerTool('gmail_delete_draft', {
+        description: 'Permanently delete a Gmail draft by its draft ID',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            draftId: z.string().min(1).describe('Draft ID to delete'),
+        },
+    }, async ({ account, draftId }) => {
+        try {
+            const auth = await getClientFn(account);
+            const gmail = gmailClient({ version: 'v1', auth });
+            await gmail.users.drafts.delete({ userId: 'me', id: draftId });
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ deleted: true, draftId }, null, 2) }],
+            };
+        }
+        catch (error) {
+            const mapped = composeErrorResult(error, account);
+            return mapped ?? handleGmailError(error, account);
+        }
+    });
     server.registerTool('gmail_list_labels', {
         description: 'List all Gmail labels (system and user-defined). Use to get label IDs for gmail_modify_labels.',
         inputSchema: {

package/dist/tools/sheets.d.ts

@@ -1,6 +1,15 @@
 import type { ToolRegistry } from '../registry.js';
 import { type CuratedToolDeps } from '../client.js';
 export declare function registerSheetsTools(server: ToolRegistry, deps?: CuratedToolDeps): void;
+interface GridRangeIndexes {
+    startRowIndex?: number;
+    endRowIndex?: number;
+    startColumnIndex?: number;
+    endColumnIndex?: number;
+}
+export declare function parseA1Range(a1: string): GridRangeIndexes & {
+    sheetName: string;
+};
 export declare function buildCellFormat(input: {
     backgroundColor?: {
         red?: number;
@@ -33,3 +42,4 @@ export declare function buildCellFormat(input: {
     format: any;
     fields: string;
 };
+export {};

package/dist/tools/sheets.js

@@ -369,6 +369,31 @@ export function registerSheetsTools(server, deps = {}) {
             return handleSheetsError(error, account);
         }
     });
+    server.registerTool('sheets_copy_sheet_to', {
+        description: 'Copy a tab into another spreadsheet (which may belong to a different account)',
+        inputSchema: {
+            account: accountEnum.describe('Google account alias'),
+            spreadsheetId: z.string().min(1).describe('Source spreadsheet ID'),
+            sheetId: z.number().describe('Source sheet ID'),
+            destinationSpreadsheetId: z.string().min(1).describe('Destination spreadsheet ID'),
+        },
+    }, async ({ account, spreadsheetId, sheetId, destinationSpreadsheetId }) => {
+        try {
+            const auth = await getClientFn(account);
+            const sheets = sheetsClient({ version: 'v4', auth });
+            const res = await sheets.spreadsheets.sheets.copyTo({
+                spreadsheetId,
+                sheetId,
+                requestBody: { destinationSpreadsheetId },
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return handleSheetsError(error, account);
+        }
+    });
     server.registerTool('sheets_update_sheet_properties', {
         description: 'Rename a tab, change tab color, freeze rows/columns, hide/show, or change grid dimensions',
         inputSchema: {
@@ -457,7 +482,8 @@ export function registerSheetsTools(server, deps = {}) {
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
             spreadsheetId: z.string().min(1).describe('Spreadsheet ID'),
-            range: gridRangeSchema.describe('Target range (GridRange, half-open indexes)'),
+            range: z.union([gridRangeSchema, z.string().min(1)])
+                .describe('Target range: a GridRange object (half-open indexes), or an A1 string such as "Sheet1!A1:D10" (the sheet title is resolved to a sheetId with one extra call)'),
             backgroundColor: rgbColorSchema.optional().describe('Cell background (RGB 0..1)'),
             textFormat: z.object({
                 foregroundColor: rgbColorSchema.optional(),
@@ -484,12 +510,16 @@ export function registerSheetsTools(server, deps = {}) {
             if (built.fields.length === 0) {
                 return invalidParams(account, 'No formatting to apply: every optional format property was omitted.', 'Pass at least one of: backgroundColor, textFormat, horizontalAlignment, verticalAlignment, wrapStrategy, numberFormat.');
             }
+            const targetRange = typeof range === 'string' ? await resolveA1GridRange(sheets, spreadsheetId, range) : range;
+            if ('error' in targetRange) {
+                return invalidParams(account, targetRange.error, targetRange.hint);
+            }
             await sheets.spreadsheets.batchUpdate({
                 spreadsheetId,
                 requestBody: {
                     requests: [{
                             repeatCell: {
-                                range,
+                                range: targetRange,
                                 cell: { userEnteredFormat: built.format },
                                 fields: built.fields,
                             },
@@ -1118,6 +1148,83 @@ const gridRangeSchema = z.object({
     startColumnIndex: z.number().min(0).optional(),
     endColumnIndex: z.number().min(0).optional(),
 });
+function columnLettersToIndex(letters) {
+    let n = 0;
+    for (const ch of letters.toUpperCase())
+        n = n * 26 + (ch.charCodeAt(0) - 64);
+    return n - 1;
+}
+const A1_CELL_RE = /^([A-Za-z]+)?(\d+)?$/;
+// Either side of ':', and either half of a side, may be omitted: whole column, row or sheet.
+export function parseA1Range(a1) {
+    const bang = a1.lastIndexOf('!');
+    const sheetPart = bang === -1 ? a1 : a1.slice(0, bang);
+    const rangePart = bang === -1 ? '' : a1.slice(bang + 1);
+    const sheetName = sheetPart.startsWith("'") && sheetPart.endsWith("'")
+        ? sheetPart.slice(1, -1).replace(/''/g, "'")
+        : sheetPart;
+    if (rangePart === '')
+        return { sheetName };
+    const [startRaw, endRaw] = rangePart.split(':');
+    const m1 = startRaw.match(A1_CELL_RE);
+    if (!m1 || (!m1[1] && !m1[2]))
+        throw new Error(`invalid A1 range "${a1}"`);
+    const [, col1, row1] = m1;
+    const out = { sheetName };
+    if (endRaw === undefined) {
+        if (col1) {
+            const c = columnLettersToIndex(col1);
+            out.startColumnIndex = c;
+            out.endColumnIndex = c + 1;
+        }
+        if (row1) {
+            const r = Number(row1) - 1;
+            out.startRowIndex = r;
+            out.endRowIndex = r + 1;
+        }
+        return out;
+    }
+    const m2 = endRaw.match(A1_CELL_RE);
+    if (!m2 || (!m2[1] && !m2[2]))
+        throw new Error(`invalid A1 range "${a1}"`);
+    const [, col2, row2] = m2;
+    if (col1)
+        out.startColumnIndex = columnLettersToIndex(col1);
+    if (col2)
+        out.endColumnIndex = columnLettersToIndex(col2) + 1;
+    if (row1)
+        out.startRowIndex = Number(row1) - 1;
+    if (row2)
+        out.endRowIndex = Number(row2);
+    return out;
+}
+async function resolveA1GridRange(sheets, spreadsheetId, a1) {
+    let parsed;
+    try {
+        parsed = parseA1Range(a1);
+    }
+    catch {
+        return {
+            error: `Could not parse A1 range "${a1}".`,
+            hint: 'Use a form like "Sheet1!A1:D10", "Sheet1!A:D", or "Sheet1" for the whole sheet.',
+        };
+    }
+    const meta = await sheets.spreadsheets.get({ spreadsheetId, fields: 'sheets.properties(sheetId,title)' });
+    const match = meta.data.sheets?.find((s) => s.properties?.title === parsed.sheetName);
+    if (!match || match.properties?.sheetId == null) {
+        return {
+            error: `No sheet/tab named "${parsed.sheetName}" in this spreadsheet.`,
+            hint: 'Check the tab name, or use sheets_get to list sheet titles and IDs.',
+        };
+    }
+    return {
+        sheetId: match.properties.sheetId,
+        startRowIndex: parsed.startRowIndex,
+        endRowIndex: parsed.endRowIndex,
+        startColumnIndex: parsed.startColumnIndex,
+        endColumnIndex: parsed.endColumnIndex,
+    };
+}
 const borderSchema = z.object({
     style: z.enum(['DOTTED', 'DASHED', 'SOLID', 'SOLID_MEDIUM', 'SOLID_THICK', 'NONE', 'DOUBLE']),
     color: rgbColorSchema.optional(),

package/dist/write-control.js

@@ -13,12 +13,12 @@ export const IRREVERSIBLE_TOOLS = new Set([
     'gmail_send',
     'gmail_send_draft',
     'gmail_delete',
+    'gmail_delete_draft',
     'gmail_batch_delete',
     'drive_delete',
     'drive_empty_trash',
     // generated twins (permanent deletes / real sends)
     'gmail_users_threads_delete',
-    'gmail_users_drafts_delete',
     'chat_spaces_messages_delete',
     'cloudidentity_customers_userinvitations_send',
     'vault_matters_holds_delete',
@@ -82,13 +82,26 @@ export function privilegeOf(tool) {
         return 'privileged_scope';
     return undefined;
 }
+/** Moves an item to Trash rather than deleting it permanently: the owner can
+ * still recover it, so safe-writes treats this like its other reversible
+ * writes despite the delete-shaped verb. Named explicitly rather than matched
+ * by verb, so a synthetic delete-classified check (drive_transfer's move
+ * flag) never qualifies by accident, and so emptying Trash, which the same
+ * verb regex also classifies as delete, is never swept in by a suffix match. */
+const TRASH_MOVE_TOOLS = new Set([
+    'gmail_trash',
+    'drive_trash',
+    'gmail_users_threads_trash',
+]);
 function profileAllows(profile, tool) {
     if (profile === 'full-writes')
         return true;
     if (profile === 'safe-writes') {
         if (privilegeOf(tool) !== undefined)
             return false;
-        return tool.cud === 'create' || tool.cud === 'update';
+        if (tool.cud === 'create' || tool.cud === 'update')
+            return true;
+        return tool.cud === 'delete' && TRASH_MOVE_TOOLS.has(tool.name);
     }
     return false;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-google-multi",
-  "version": "6.0.0-beta.4",
+  "version": "6.0.0",
   "mcpName": "io.github.bakissation/mcp-google-multi",
   "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",
@@ -36,7 +36,8 @@
     "./package.json": "./package.json"
   },
   "files": [
-    "dist"
+    "dist",
+    "skills"
   ],
   "engines": {
     "node": ">=22"
@@ -85,6 +86,7 @@
     "gen:discovery": "tsx scripts/fetch-discovery.ts",
     "gen:tools": "tsx scripts/gen-tools.ts",
     "gen:coverage": "tsx scripts/gen-coverage.ts",
+    "gen:skill": "tsx scripts/gen-skill.ts",
     "eval:contract": "npx --yes promptfoo@0.123.1 eval -c eval/contract/promptfooconfig.yaml --no-progress-bar",
     "measure:lazy": "node scripts/measure-tools.mjs",
     "pack:mcpb": "mcpb pack . mcp-google-multi.mcpb",