mcp-google-multi 5.4.1-alpha.2 → 6.0.0-alpha.2

package/dist/tools/docs.js

@@ -1,11 +1,54 @@
 import { z } from 'zod';
 import { coerceBoolean, coerceJson } from './_coerce.js';
 import { docs as docsClient } from '@googleapis/docs';
-import { ACCOUNTS } from '../accounts.js';
+import { accountAliasSchema } from '../accounts.js';
 import { getClient } from '../client.js';
 import { handleGoogleApiError } from './_errors.js';
 import { capText } from '../trim.js';
-const accountEnum = z.enum(ACCOUNTS);
+const accountEnum = accountAliasSchema.optional();
+// A single very large insertText has been observed to apply only partially while
+// the request still returns success, silently dropping the tail. Split a large
+// insert into bounded pieces sent as sequential insertText requests in one atomic
+// batchUpdate: small inserts keep the exact single-request path, and a large one
+// can no longer be silently truncated. Docs indices are UTF-16 code units (= JS
+// string length), so index math advances by `.length`; never split a surrogate pair.
+export const DOCS_INSERT_CHUNK = 5000;
+export function splitInsertText(text, maxLen = DOCS_INSERT_CHUNK) {
+    if (text.length === 0)
+        return [];
+    if (text.length <= maxLen)
+        return [text];
+    const chunks = [];
+    let i = 0;
+    while (i < text.length) {
+        let end = Math.min(i + maxLen, text.length);
+        if (end < text.length) {
+            const code = text.charCodeAt(end - 1);
+            if (code >= 0xd800 && code <= 0xdbff)
+                end -= 1; // keep a surrogate pair together
+        }
+        chunks.push(text.slice(i, end));
+        i = end;
+    }
+    return chunks;
+}
+// Sequential insertText requests: appends chain at end-of-segment; index inserts
+// advance the cursor by each prior chunk's length so the pieces stay contiguous.
+export function buildInsertRequests(text, index) {
+    const chunks = splitInsertText(text);
+    const requests = [];
+    let cursor = index;
+    for (const chunk of chunks) {
+        if (cursor === undefined) {
+            requests.push({ insertText: { text: chunk, endOfSegmentLocation: { segmentId: '' } } });
+        }
+        else {
+            requests.push({ insertText: { text: chunk, location: { index: cursor } } });
+            cursor += chunk.length;
+        }
+    }
+    return requests;
+}
 function extractPlainText(body) {
     return extractPlainTextInRange(body, 0, Infinity);
 }
@@ -304,21 +347,23 @@ export function registerDocsTools(server) {
         try {
             const auth = await getClient(account);
             const docs = docsClient({ version: 'v1', auth });
-            const request = { insertText: { text } };
-            if (index !== undefined) {
-                request.insertText.location = { index };
-            }
-            else {
-                request.insertText.endOfSegmentLocation = { segmentId: '' };
+            const requests = buildInsertRequests(text, index);
+            if (requests.length === 0) {
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({
+                                documentId, insertedAt: index ?? 'end', inserted: 0,
+                            }, null, 2) }],
+                };
             }
             const res = await docs.documents.batchUpdate({
                 documentId,
-                requestBody: { requests: [request] },
+                requestBody: { requests },
             });
             return {
                 content: [{ type: 'text', text: JSON.stringify({
                             documentId: res.data.documentId,
                             insertedAt: index ?? 'end',
+                            inserted: text.length,
                         }, null, 2) }],
             };
         }
@@ -327,6 +372,8 @@ export function registerDocsTools(server) {
         }
     });
     server.registerTool('docs_replace_text', {
+        // Insert/append-capable or non-convergent: a retry duplicates content.
+        annotations: { idempotentHint: false },
         description: 'Find and replace all occurrences of text in a document',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
@@ -978,6 +1025,8 @@ export function registerDocsTools(server) {
     });
     // ─── Table mutations (one tool with operation discriminator) ───────────
     server.registerTool('docs_modify_table', {
+        // Insert/append-capable or non-convergent: a retry duplicates content.
+        annotations: { idempotentHint: false },
         description: 'Mutate a table by operation: insertRow, insertColumn, deleteRow, deleteColumn, mergeCells, unmergeCells. Locate the cell with tableStartIndex (the table\'s start index in the doc) plus rowIndex/columnIndex (0-based).',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
@@ -1156,6 +1205,8 @@ export function registerDocsTools(server) {
     });
     // ─── Batch update escape hatch ─────────────────────────────────────────
     server.registerTool('docs_batch_update', {
+        // Insert/append-capable or non-convergent: a retry duplicates content.
+        annotations: { idempotentHint: false },
         description: 'Generic documents.batchUpdate pass-through. Accepts the full Request union (40 types). See https://developers.google.com/workspace/docs/api/reference/rest/v1/documents/request',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),

package/dist/tools/drive.d.ts

@@ -1,5 +1,8 @@
 import type { ToolRegistry } from '../registry.js';
 export declare function prepareLocalDest(savePath: string, filename: string): string;
+export declare const DRIVE_QUERY_HINT: string;
+export declare function normalizeDriveQuery(raw: string): string;
+export declare function isDriveInvalidQuery(error: any): boolean;
 export declare function resolveShareNotification(opts: {
     type: string;
     role: string;

package/dist/tools/drive.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { coerceArray, coerceBoolean } from './_coerce.js';
 import { drive as driveClient } from '@googleapis/drive';
-import { ACCOUNTS, ACCOUNT_CONFIG } from '../accounts.js';
+import { accountAliasSchema, getAccountSet } from '../accounts.js';
 import { getClient } from '../client.js';
 import { handleGoogleApiError } from './_errors.js';
 import { isAllowed, writeDisabledResult } from '../write-control.js';
@@ -12,7 +12,10 @@ import * as os from 'os';
 import * as crypto from 'crypto';
 import { pipeline } from 'node:stream/promises';
 import mime from 'mime-types';
-const accountEnum = z.enum(ACCOUNTS);
+const accountEnum = accountAliasSchema.optional();
+// drive_transfer's two-account form is the sanctioned schema exception and
+// stays REQUIRED: omission must fail at the schema, not as a runtime riddle.
+const requiredAccountEnum = accountAliasSchema;
 const MAX_FILE_SIZE = 2 * 1024 * 1024; // 2MB
 const FALLBACK_MAX_BYTES = 1024 * 1024 * 1024; // 1GB
 const GOOGLE_WORKSPACE_TYPES = new Set([
@@ -34,6 +37,41 @@ export function prepareLocalDest(savePath, filename) {
     fs.mkdirSync(savePath, { recursive: true });
     return dest;
 }
+export const DRIVE_QUERY_HINT = "Drive search syntax: a plain keyword is treated as a full-text search, but a " +
+    "structured query needs an operator, e.g. \"name contains 'report'\", " +
+    "\"mimeType = 'application/pdf'\", or \"'me' in owners\". " +
+    'Reference: https://developers.google.com/drive/api/guides/search-files';
+// A bare keyword is not valid Drive `q` syntax (Google 400s "Invalid Value"), yet
+// it is the natural thing to pass to a "search" tool, so wrap it as a full-text
+// match. A query already carrying a comparison operator or a quoted literal is a
+// structured query and is passed through untouched.
+export function normalizeDriveQuery(raw) {
+    const q = raw.trim();
+    if (q === '')
+        return q;
+    // Structured iff it carries a comparison operator or the membership form
+    // "<value> in (parents|owners|writers|readers)". A bare apostrophe does NOT
+    // count (names like O'Brien are keywords, not query syntax).
+    const hasComparison = /(\bcontains\b|!=|<=|>=|[=<>])/i.test(q);
+    const hasMembership = /\bin\s+(parents|owners|writers|readers)\b/i.test(q);
+    if (hasComparison || hasMembership)
+        return q;
+    const escaped = q.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+    return `fullText contains '${escaped}'`;
+}
+// Drive rejects a malformed query with HTTP 400 / reason "invalid" and the opaque
+// message "Invalid Value"; detect that so drive_search returns query-syntax help
+// instead of a generic upstream_error.
+export function isDriveInvalidQuery(error) {
+    const raw = error?.code ?? error?.status ?? error?.response?.status;
+    const status = typeof raw === 'string' ? Number(raw) : raw;
+    if (status !== 400)
+        return false;
+    const reason = error?.errors?.[0]?.reason ??
+        error?.response?.data?.error?.errors?.[0]?.reason;
+    const message = error?.response?.data?.error?.message ?? error?.message ?? '';
+    return reason === 'invalid' || reason === 'invalidQuery' || /invalid value/i.test(String(message));
+}
 // sendNotificationEmail is only valid for user/group permissions, and Google forbids
 // disabling it on an ownership transfer. Returns undefined to omit the param entirely.
 export function resolveShareNotification(opts) {
@@ -46,10 +84,10 @@ export function resolveShareNotification(opts) {
 export function registerDriveTools(server) {
     // ─── Read / search / list ──────────────────────────────────────────────
     server.registerTool('drive_search', {
-        description: 'Search files in a Google Drive account',
+        description: 'Search files in a Google Drive account. A plain keyword is treated as a full-text search; pass Drive query syntax for a structured search.',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
-            query: z.string().describe('Drive search syntax, e.g. "name contains \'MoU\'"'),
+            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)'),
             driveId: z.string().optional().describe('Optional shared drive ID'),
@@ -59,7 +97,7 @@ export function registerDriveTools(server) {
             const auth = await getClient(account);
             const drive = driveClient({ version: 'v3', auth });
             const params = {
-                q: query,
+                q: normalizeDriveQuery(query),
                 pageSize: maxResults ?? 20,
                 fields: 'files(id,name,mimeType,modifiedTime,webViewLink,size,parents,driveId)',
                 supportsAllDrives: true,
@@ -75,10 +113,24 @@ export function registerDriveTools(server) {
             };
         }
         catch (error) {
+            if (isDriveInvalidQuery(error)) {
+                const message = error?.response?.data?.error?.message ?? error?.message ?? 'Invalid Value';
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({
+                                error: 'invalid_query',
+                                message,
+                                hint: DRIVE_QUERY_HINT,
+                                retriable: false,
+                                account,
+                            }) }],
+                    isError: true,
+                };
+            }
             return handleDriveError(error, account);
         }
     });
     server.registerTool('drive_read', {
+        _meta: { 'anthropic/maxResultSizeChars': 100_000 },
         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'),
@@ -1095,8 +1147,8 @@ export function registerDriveTools(server) {
             'revision history, and permissions do not transfer. move=true trashes the source after a ' +
             'successful copy and requires deletes to be allowed by write-control.',
         inputSchema: {
-            fromAccount: accountEnum.describe('Source account alias'),
-            toAccount: accountEnum.describe('Target account alias'),
+            fromAccount: requiredAccountEnum.describe('Source account alias'),
+            toAccount: requiredAccountEnum.describe('Target account alias'),
             fileId: z.string().describe('File ID in the source account (folders are not supported)'),
             parentFolderId: z.string().optional().describe('Target folder ID (default: target My Drive root)'),
             newName: z.string().optional().describe('Rename the copy (default: keep the source name)'),
@@ -1150,7 +1202,7 @@ export function registerDriveTools(server) {
                 };
             }
             const intendedName = newName ?? meta.data.name ?? 'transferred-file';
-            const targetEmail = ACCOUNT_CONFIG[toAccount].email;
+            const targetEmail = getAccountSet().configs[toAccount].email;
             const finish = async (data, strategy, flags) => {
                 let moveFailed = false;
                 let moveSkipped = false;

package/dist/tools/forms.js

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 import { forms as formsClient } from '@googleapis/forms';
-import { ACCOUNTS } from '../accounts.js';
+import { accountAliasSchema } from '../accounts.js';
 import { getClient } from '../client.js';
 import { handleGoogleApiError } from './_errors.js';
 import { coerceArray, coerceBoolean, coerceJson } from './_coerce.js';
-const accountEnum = z.enum(ACCOUNTS);
+const accountEnum = accountAliasSchema.optional();
 export function registerFormsTools(server) {
     server.registerTool('forms_get', {
         description: 'Get a Google Form (definition: questions, sections, settings). Requires forms.body scope.',
@@ -119,6 +119,8 @@ export function registerFormsTools(server) {
         }
     });
     server.registerTool('forms_batch_update', {
+        // Insert/append-capable or non-convergent: a retry duplicates content.
+        annotations: { idempotentHint: false },
         description: 'Generic forms.batchUpdate pass-through: add/edit/delete questions, update form info and settings. See https://developers.google.com/workspace/forms/api/reference/rest/v1/forms/request',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),

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

@@ -15,7 +15,5 @@ export interface GeneratedToolDef {
     hasBody: boolean;
     shape: z.ZodRawShape;
 }
-export declare function accountField(): z.ZodEnum<{
-    [x: string]: string;
-}>;
+export declare function accountField(): z.ZodOptional<z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>>;
 export declare function registerGeneratedTool(registry: ToolRegistry, def: GeneratedToolDef, deps?: ExecuteDeps): void;

package/dist/tools/generated/_shared.js

@@ -1,8 +1,7 @@
-import { z } from 'zod';
-import { ACCOUNTS } from '../../accounts.js';
+import { accountAliasSchema } from '../../accounts.js';
 import { executeApiMethod } from '../../executor.js';
 export function accountField() {
-    return z.enum(ACCOUNTS).describe('Google account alias');
+    return accountAliasSchema.optional().describe('Google account alias (omit for the default account)');
 }
 export function registerGeneratedTool(registry, def, deps = {}) {
     // Widened locally: `cud` is a registry extension the SDK config type doesn't
@@ -13,6 +12,7 @@ export function registerGeneratedTool(registry, def, deps = {}) {
         inputSchema: def.shape,
         cud: def.cud,
         annotations: { openWorldHint: true },
+        requiredScopes: def.method.scopes,
     }, async (args) => {
         const pathParams = {};
         const queryParams = {};