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

package/dist/tools/gmail.js

@@ -1,11 +1,11 @@
 import { z } from 'zod';
 import { coerceArray, coerceBoolean, coerceJson, coerceNumber } from './_coerce.js';
 import { gmail as gmailClient } from '@googleapis/gmail';
-import { accountAliasSchema } from '../accounts.js';
+import { accountArgLive } from '../accounts.js';
 import { getClient } from '../client.js';
 import { handleGoogleApiError, invalidParams, mapGoogleError } from './_errors.js';
 import { buildReplyHeaders, composeRaw, renderMarkdown, htmlToMarkdown, HeaderInjectionError } from './gmail-mime.js';
-import { prepareLocalDest } from './_local-files.js';
+import { hostFilesRefused, prepareLocalDest } from './_local-files.js';
 import { checkOutbound } from '../outbound-allowlist.js';
 import addressparser from 'nodemailer/lib/addressparser/index.js';
 import { lookup as lookupMime } from 'mime-types';
@@ -14,7 +14,6 @@ import { getTokenDir } from '../accounts.js';
 import { sliceClean } from '../trim.js';
 import * as path from 'path';
 import * as fs from 'fs';
-const accountEnum = accountAliasSchema.optional();
 function getHeader(headers, name) {
     return headers?.find((h) => h.name?.toLowerCase() === name.toLowerCase())?.value ?? '';
 }
@@ -39,16 +38,15 @@ function decodeBody(payload, rawHtml = false) {
     const plain = [];
     const html = [];
     collectTextParts(payload, plain, html, true);
-    // Concatenating every plain leaf keeps forwarded/mixed messages whole;
-    // any plain content beats HTML because alternatives duplicate the same body.
-    // A plain leaf is returned verbatim (byte-identical to v5).
+    // Concatenating every plain leaf keeps forwarded/mixed messages whole; plain
+    // always wins over HTML since alternatives duplicate the same body.
     if (plain.length > 0)
         return { body: plain.join('\n\n'), bodyFormat: 'plain' };
     if (html.length > 0) {
         const joined = html.join('\n\n');
         if (rawHtml)
             return { body: joined, bodyFormat: 'html' };
-        // HTML-only -> Markdown (D6). turndown failure degrades to plain text.
+        // HTML-only -> Markdown. turndown failure degrades to plain text.
         const { text, ok } = htmlToMarkdown(joined);
         return { body: text, bodyFormat: ok ? 'markdown' : 'plain' };
     }
@@ -92,9 +90,8 @@ function parseAddresses(headerValue) {
     return out;
 }
 const normAddr = (a) => a.trim().toLowerCase();
-/** Rebuild a comma-separated address header; composeRaw/MailComposer re-encodes
- * names (RFC 2047) and the A4 CRLF pre-check applies, so derived recipients get
- * the same header-injection guard as caller-supplied ones. */
+/** Rebuilds a comma-separated address header; composeRaw/MailComposer re-encodes
+ * names and apply the same header-injection guard as caller-supplied recipients. */
 function formatAddresses(list) {
     return list.map((a) => (a.name ? `${a.name} <${a.address}>` : a.address)).join(', ');
 }
@@ -104,12 +101,12 @@ export function deriveReplySubject(sourceSubject) {
     const s = sourceSubject.trim();
     return /^re:/i.test(s) ? s : `Re: ${s}`;
 }
-// The account's own-address set (primary + Gmail send-as aliases) used to
-// exclude the caller from reply-all. Send-as rarely changes, so memoize per
-// process; a stale miss only costs one extra self-copy, never a wrong send.
+// Own-address set (primary + send-as aliases) for excluding the caller from
+// reply-all; memoized per-process (a stale miss just costs one self-copy), keyed by alias+mailbox.
 const ownAddressCache = new Map();
 function getOwnAddresses(gmail, account, primaryEmail) {
-    let cached = ownAddressCache.get(account);
+    const key = `${account} ${normAddr(primaryEmail)}`;
+    let cached = ownAddressCache.get(key);
     if (!cached) {
         cached = (async () => {
             const set = new Set([normAddr(primaryEmail)]);
@@ -121,17 +118,17 @@ function getOwnAddresses(gmail, account, primaryEmail) {
                 }
             }
             catch {
-                // insufficient_scope / 5xx: degrade to the primary alone, never block the send.
+                // insufficient_scope/5xx: degrade silently
             }
             return set;
         })();
-        ownAddressCache.set(account, cached);
+        ownAddressCache.set(key, cached);
     }
     return cached;
 }
 /** Fetch the reply source once and derive threading headers plus (auto-fill)
  * to/cc/subject. On any fetch failure, degrade to the API id for threading and
- * report sourceFound:false so the caller can decide (per A8 error dispositions). */
+ * report sourceFound:false so the caller can decide. */
 export async function resolveReply(gmail, account, primaryEmail, replyToMessageId, replyAll) {
     let headers;
     try {
@@ -144,7 +141,7 @@ export async function resolveReply(gmail, account, primaryEmail, replyToMessageI
         headers = meta.data.payload?.headers;
     }
     catch {
-        // Degrade to the API id (pre-lookup behavior) rather than blocking the send.
+        // Degrade to the API id rather than blocking the send.
         return { inReplyTo: replyToMessageId, references: replyToMessageId, sourceFound: false };
     }
     const threading = buildReplyHeaders(replyToMessageId, getHeader(headers, 'Message-ID'), getHeader(headers, 'References'));
@@ -180,15 +177,11 @@ export async function resolveReply(gmail, account, primaryEmail, replyToMessageI
     };
 }
 const BODY_CAP_CHARS = 50_000;
-// gmail_read_batch aggregate ceiling: a batch of up to 100 messages must never
-// blow the context window, so the summed serialized output is bounded here
-// (matches the tool's anthropic/maxResultSizeChars hint). Per-message bodies are
-// still individually capped at BODY_CAP_CHARS first.
+// 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).
 const BATCH_MAX_RESULT_CHARS = 100_000;
-// Gmail's messages.send raw/JSON path rejects messages near ~25 MB (the wire
-// message is base64-encoded, ~+33% over the raw bytes), so cap the ESTIMATED
-// ENCODED total there rather than the spec's nominal 35 MB raw (spike/live
-// correction — a 35 MB raw payload is ~47 MB on the wire and Gmail 400s it).
+// messages.send rejects near ~25MB on the wire (base64 adds ~33%), so cap the
+// estimated ENCODED total here rather than the nominal 35MB raw limit, which 400s at ~47MB wire.
 const GMAIL_MAX_MESSAGE_BYTES = 25 * 1024 * 1024;
 const estimateEncoded = (rawBytes) => Math.ceil((rawBytes * 4) / 3);
 const attachmentSchema = z
@@ -202,10 +195,8 @@ const attachmentSchema = z
 /** Reads attachment files into buffers (THIS server reads them, never
  * MailComposer), enforces absolute-path + total-size guards, and derives the
  * MIME filename via basename so a caller name can't inject path separators. */
-// Deny reading anything inside the server's own secret dirs — mailing out
-// master.key / <alias>.enc / mcp-jwt.key would be a full-account-takeover
-// exfil channel (this same server also reads untrusted mail/drive content, so
-// a prompt-injected attach path is a real confused-deputy vector).
+// Deny reading inside the server's own secret dirs; mailing out master.key /
+// <alias>.enc / mcp-jwt.key would be account takeover (also guards against a prompt-injected attach path).
 function isInside(dir, target) {
     let d = path.resolve(dir);
     let t = path.resolve(target);
@@ -279,9 +270,8 @@ export async function readAttachments(raw, bodyBytes) {
     }
     return out;
 }
-/** Tagged compose-time failure; the handlers map it to an isError envelope.
- * `category` is the taxonomy error field (default validation_error); reply
- * auto-fill raises it as not_found when a source message can't be fetched. */
+/** Tagged compose-time failure mapped to an isError envelope; `category`
+ * defaults to validation_error (reply auto-fill raises not_found instead). */
 class GmailComposeError extends Error {
     slug;
     category;
@@ -335,7 +325,7 @@ export function parseMessage(msg, bodyCap, opts) {
     };
 }
 /**
- * A9 gmail_read_batch core: fetch N ids with bounded parallelism, parse each,
+ * gmail_read_batch core: fetch N ids with bounded parallelism, parse each,
  * and bound the aggregate output. Order is preserved by input index. A per-id
  * failure becomes a `{ id, error }` entry; an account-wide auth/scope failure
  * is rethrown so the caller maps it to a whole-call isError. Returns the
@@ -382,9 +372,8 @@ export async function readBatch(gmail, account, ids, full, rawHtml) {
             }
         }
     }
-    // Aggregate guard: walk in order, accumulating serialized size. Once the
-    // running total would exceed the maxResultSizeChars budget, cap this and every
-    // later success body so a big batch never blows the context window.
+    // 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.
     let running = 0;
     let truncatedAny = false;
     let exhausted = false;
@@ -436,13 +425,19 @@ export function compactMessageRow(m) {
         snippet: snippet.length > 120 ? `${snippet.slice(0, 119)}…` : snippet,
     };
 }
-export function registerGmailTools(server) {
+export function registerGmailTools(server, deps = {}) {
+    // Per-registry, live account enum + injectable client: the schema follows
+    // the registry's account view at parse time, not a process-global default.
+    const accountEnum = accountArgLive(() => server.accountAliases()).optional();
+    const getClientFn = deps.getClientFn ?? getClient;
+    const localFiles = deps.localFiles ?? true;
+    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.',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
-            query: z.string().describe('Gmail search syntax, e.g. "from:monaam is:unread"'),
+            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'),
@@ -454,7 +449,7 @@ export function registerGmailTools(server) {
             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.');
             }
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             const listRes = await gmail.users.messages.list({
                 userId: 'me',
@@ -486,9 +481,8 @@ 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.
+            // Search is a pick-one-message step almost always followed by gmail_read;
+            // the compact row is the selection signal (full=true returns the previous, heavier row).
             const rows = full === true ? results : results.map(compactMessageRow);
             return {
                 content: [{ type: 'text', text: JSON.stringify(rows, null, 2) }],
@@ -511,7 +505,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account, messageId, full, rawHtml }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             const res = await gmail.users.messages.get({
                 userId: 'me',
@@ -542,7 +536,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account, threadId, full, rawHtml, mode }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             if (mode === 'summary') {
                 const res = await gmail.users.threads.get({
@@ -592,7 +586,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account, ids, full, rawHtml }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             const result = await readBatch(gmail, account, ids ?? [], full === true, rawHtml === true);
             return {
@@ -622,13 +616,15 @@ export function registerGmailTools(server) {
                 .describe('With replyToMessageId: include the source To+Cc (minus your own addresses) in cc. Default false (reply to sender only).'),
             replyToThreadId: z.string().optional()
                 .describe('Thread ID to send the message in'),
-            attachments: coerceJson(attachmentSchema),
+            ...(localFiles ? { attachments: coerceJson(attachmentSchema) } : {}),
         },
     }, async ({ account, to, subject, body, htmlBody, allowRawHtml, cc, replyToMessageId, replyAll, replyToThreadId, attachments }) => {
+        if (!localFiles && attachments?.length)
+            return hostFilesRefused(account, 'attachments');
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
-            const config = (await import('../accounts.js')).getAccountSet().configs[account];
+            const config = server.accountSet().configs[account];
             if (htmlBody !== undefined) {
                 throw new GmailComposeError('E_HTMLBODY_REMOVED', 'htmlBody was removed in v6: author Markdown in `body`; for literal HTML pass `allowRawHtml: true`.');
             }
@@ -686,7 +682,7 @@ export function registerGmailTools(server) {
             return mapped ?? handleGmailError(error, account);
         }
     });
-    server.registerTool('gmail_download_attachment', {
+    registerHostFileTool('gmail_download_attachment', {
         description: 'Download an email attachment to local disk. Use gmail_read first to get the attachmentId.',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
@@ -697,7 +693,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account, messageId, attachmentId, filename, savePath }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             const res = await gmail.users.messages.attachments.get({
                 userId: 'me',
@@ -737,13 +733,15 @@ export function registerGmailTools(server) {
                 .describe('With replyToMessageId: include the source To+Cc (minus your own addresses) in cc. Default false (reply to sender only).'),
             replyToThreadId: z.string().optional()
                 .describe('Thread ID to associate the draft with'),
-            attachments: coerceJson(attachmentSchema),
+            ...(localFiles ? { attachments: coerceJson(attachmentSchema) } : {}),
         },
     }, async ({ account, to, subject, body, htmlBody, allowRawHtml, cc, replyToMessageId, replyAll, replyToThreadId, attachments }) => {
+        if (!localFiles && attachments?.length)
+            return hostFilesRefused(account, 'attachments');
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
-            const config = (await import('../accounts.js')).getAccountSet().configs[account];
+            const config = server.accountSet().configs[account];
             if (htmlBody !== undefined) {
                 throw new GmailComposeError('E_HTMLBODY_REMOVED', 'htmlBody was removed in v6: author Markdown in `body`; for literal HTML pass `allowRawHtml: true`.');
             }
@@ -811,7 +809,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account, messageId, addLabelIds, removeLabelIds }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             const res = await gmail.users.messages.modify({
                 userId: 'me',
@@ -838,7 +836,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account, messageId }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             const res = await gmail.users.messages.trash({ userId: 'me', id: messageId });
             return {
@@ -858,7 +856,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account, messageId }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             await gmail.users.messages.delete({ userId: 'me', id: messageId });
             return {
@@ -880,7 +878,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account, messageIds, addLabelIds, removeLabelIds }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             await gmail.users.messages.batchModify({
                 userId: 'me',
@@ -907,7 +905,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account, messageIds }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             await gmail.users.messages.batchDelete({
                 userId: 'me',
@@ -932,7 +930,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account, maxResults, query }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             const res = await gmail.users.drafts.list({
                 userId: 'me',
@@ -956,7 +954,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account, draftId }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             const res = await gmail.users.drafts.get({
                 userId: 'me',
@@ -980,7 +978,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account, draftId }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             const res = await gmail.users.drafts.send({
                 userId: 'me',
@@ -1002,7 +1000,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             const res = await gmail.users.labels.list({ userId: 'me' });
             return {
@@ -1026,7 +1024,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account, name, messageListVisibility, labelListVisibility }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             const res = await gmail.users.labels.create({
                 userId: 'me',
@@ -1053,7 +1051,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account, labelId }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             await gmail.users.labels.delete({ userId: 'me', id: labelId });
             return {
@@ -1072,7 +1070,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             const res = await gmail.users.getProfile({ userId: 'me' });
             return {
@@ -1096,7 +1094,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account, startHistoryId, maxResults, historyTypes }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             const res = await gmail.users.history.list({
                 userId: 'me',
@@ -1120,7 +1118,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             const res = await gmail.users.settings.getVacation({ userId: 'me' });
             return {
@@ -1146,7 +1144,7 @@ export function registerGmailTools(server) {
         },
     }, async ({ account, enableAutoReply, responseSubject, responseBodyPlainText, startTime, endTime, restrictToContacts, restrictToDomain }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const gmail = gmailClient({ version: 'v1', auth });
             const res = await gmail.users.settings.updateVacation({
                 userId: 'me',

package/dist/tools/google-api.d.ts

@@ -1,10 +1,9 @@
 import type { ToolRegistry } from '../registry.js';
 import { type Policy } from '../write-control.js';
-import { getClient } from '../client.js';
 import { type Toolsets } from '../toolsets.js';
+import { type ExecuteDeps } from '../executor.js';
 import { type DiscoveryDeps, type DiscoveryMethod } from '../discovery-client.js';
-export interface EscapeDeps extends DiscoveryDeps {
-    getClientFn?: typeof getClient;
+export interface EscapeDeps extends DiscoveryDeps, ExecuteDeps {
     toolsets?: Toolsets;
 }
 /** Up to three closest known ids for the unknown_method did-you-mean hint;

package/dist/tools/google-api.js

@@ -1,13 +1,13 @@
 import { z } from 'zod';
 import { isAllowed, writeDisabledResult } from '../write-control.js';
-import { accountAliasSchema } from '../accounts.js';
+import { accountArgLive } from '../accounts.js';
 import { getClient } from '../client.js';
 import { coerceJson } from './_coerce.js';
 import { getToolsets, toolsetEnabled } from '../toolsets.js';
-import { editDistance } from '../scope-catalog.js';
+import { editDistance, SUGGEST_MAX_INPUT } from '../scope-catalog.js';
 import { executeApiMethod, jsonResult } from '../executor.js';
-import { SUPPORTED_APIS, resolveApiAliases, cudFromMethod, loadMethodIndex, searchMethods, } from '../discovery-client.js';
-const accountEnum = accountAliasSchema.optional();
+import { SUPPORTED_APIS, resolveApiAliases, cudFromMethod, loadMethodIndex, searchMethods, MAX_SEARCH_QUERY, } from '../discovery-client.js';
+import { hints } from '../hint-provider.js';
 // Policy/toolset namespace for each API alias must match the NAMED tools' service
 // names, or user deny globs and GOOGLE_TOOLSETS silently miss escape-hatch calls.
 const SERVICE_FOR_ALIAS = {
@@ -32,12 +32,21 @@ const SERVICE_FOR_ALIAS = {
     analyticsadmin: 'analytics',
     analyticsdata: 'analytics',
 };
+/** Discovery ids are short dotted identifiers; the bound keeps a caller from
+ * sending megabytes through lookup, suggestion and the echoed message. */
+const MAX_METHOD_ID = 256;
+const MAX_API_ALIAS = 64;
 /** Up to three closest known ids for the unknown_method did-you-mean hint;
  * bounded distance so unrelated ids never masquerade as suggestions. */
 export function nearestMethodIds(methodId, index) {
+    if (methodId.length > SUGGEST_MAX_INPUT)
+        return [];
     const maxDist = Math.max(3, Math.floor(methodId.length / 3));
+    const wanted = methodId.toLowerCase();
     return index
-        .map((m) => ({ id: m.id, d: editDistance(methodId.toLowerCase(), m.id.toLowerCase()) }))
+        // the distance is at least the length gap, so most ids skip the DP
+        .filter((m) => Math.abs(m.id.length - wanted.length) <= maxDist)
+        .map((m) => ({ id: m.id, d: editDistance(wanted, m.id.toLowerCase()) }))
         .filter((x) => x.d <= maxDist)
         .sort((a, b) => a.d - b.d)
         .slice(0, 3)
@@ -55,6 +64,8 @@ function describeMethod(m) {
     };
 }
 export function registerEscapeTools(registry, policy, deps = {}) {
+    // Live per-registry account validation, same as the curated files.
+    const accountEnum = accountArgLive(() => registry.accountAliases()).optional();
     const getClientFn = deps.getClientFn ?? getClient;
     const toolsets = deps.toolsets ?? getToolsets();
     const serviceForAlias = (alias) => SERVICE_FOR_ALIAS[alias] ?? alias;
@@ -63,19 +74,22 @@ export function registerEscapeTools(registry, policy, deps = {}) {
     };
     const enabledApis = Object.keys(SUPPORTED_APIS).filter(apiEnabled);
     const apiList = enabledApis.join(', ');
-    const toolsetDisabled = (alias) => jsonResult({
-        error: 'toolset_disabled',
-        message: `API "${alias}" maps to service "${serviceForAlias(alias)}", which is excluded by GOOGLE_TOOLSETS.`,
-        hint: 'Add the service to GOOGLE_TOOLSETS (or unset it) to use this API.',
-        retriable: false,
-    }, true);
+    const toolsetDisabled = (alias) => {
+        const rendered = hints()?.render({ kind: 'toolset_disabled', api: alias, service: serviceForAlias(alias) });
+        return jsonResult({
+            error: 'toolset_disabled',
+            message: rendered?.message ?? `API "${alias}" maps to service "${serviceForAlias(alias)}", which is excluded by GOOGLE_TOOLSETS.`,
+            hint: rendered?.hint ?? 'Add the service to GOOGLE_TOOLSETS (or unset it) to use this API.',
+            retriable: false,
+        }, true);
+    };
     registry.registerMeta('google_api_search', {
         description: 'Search the Google API Discovery index for any Workspace REST method, including ones with no ' +
             'dedicated tool here. Returns method ids + parameters to invoke via google_api_call. ' +
             `APIs: ${apiList}.`,
         inputSchema: {
-            query: z.string().describe('Keywords, e.g. "slides create presentation" or "drive revisions"'),
-            api: z.string().optional().describe('Restrict the search to one API alias'),
+            query: z.string().max(MAX_SEARCH_QUERY).describe('Keywords, e.g. "slides create presentation" or "drive revisions"'),
+            api: z.string().max(MAX_API_ALIAS).optional().describe('Restrict the search to one API alias'),
             maxResults: z.number().min(1).max(25).default(10).optional(),
         },
         annotations: { openWorldHint: true },
@@ -125,8 +139,8 @@ export function registerEscapeTools(registry, policy, deps = {}) {
             'drive.files.export) use drive_download / drive_export instead.',
         inputSchema: {
             account: accountEnum.describe('Google account alias (omit for the default account)'),
-            api: z.string().describe(`API alias: ${apiList}`),
-            methodId: z.string().min(1).describe('Discovery method id, e.g. "drive.revisions.list"'),
+            api: z.string().max(MAX_API_ALIAS).describe(`API alias: ${apiList}`),
+            methodId: z.string().min(1).max(MAX_METHOD_ID).describe('Discovery method id, e.g. "drive.revisions.list"'),
             pathParams: coerceJson(z.record(z.string(), z.union([z.string(), z.number()])).optional())
                 .describe('Values for {placeholders} in the method path'),
             queryParams: coerceJson(z
@@ -164,9 +178,8 @@ export function registerEscapeTools(registry, policy, deps = {}) {
         }
         let method = index.find((m) => m.id === methodId);
         if (!method) {
-            // Some discovery docs keep a legacy id prefix (the searchconsole doc's
-            // methods are webmasters.*): when the caller prefixed with our api
-            // alias, retry under the doc's own prefix before failing.
+            // Some discovery docs keep a legacy id prefix (searchconsole's methods are
+            // webmasters.*): retry under the doc's own prefix if the caller used our api alias.
             const docPrefix = index[0]?.id.split('.')[0];
             const [head, ...rest] = String(methodId).split('.');
             if (docPrefix && (head === apiKey || head === api) && head !== docPrefix && rest.length > 0) {
@@ -191,9 +204,8 @@ export function registerEscapeTools(registry, policy, deps = {}) {
         const cud = cudFromMethod(method);
         const policyService = serviceForAlias(apiKey);
         const lastSegment = method.id.split('.').pop() ?? method.id;
-        // The escape hatch self-gates, so it needs the same scope signal the
-        // registry wrapper gets; without it a privileged method would slip past
-        // safe-writes here while its generated twin is refused.
+        // The escape hatch self-gates, so it needs the same scope signal as the registry
+        // wrapper, or a privileged method would slip past safe-writes here while its generated twin is refused.
         const toolRef = { name: `${policyService}_${lastSegment}`, service: policyService, cud, scopes: method.scopes };
         if (cud !== 'read' && !isAllowed(toolRef, policy)) {
             return writeDisabledResult(toolRef, policy, account);
@@ -203,6 +215,6 @@ export function registerEscapeTools(registry, policy, deps = {}) {
             pathParams: pathParams,
             queryParams: queryParams,
             body,
-        }, { getClientFn });
+        }, { getClientFn, scopeDeps: deps.scopeDeps });
     });
 }

package/dist/tools/meet.d.ts

@@ -1,2 +1,11 @@
 import type { ToolRegistry } from '../registry.js';
-export declare function registerMeetTools(server: ToolRegistry): void;
+import type { Account } from '../accounts.js';
+import { type CuratedToolDeps } from '../client.js';
+export declare function registerMeetTools(server: ToolRegistry, deps?: CuratedToolDeps): void;
+export declare function handleMeetError(error: any, account: Account): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: true;
+};

package/dist/tools/meet.js

@@ -1,10 +1,13 @@
 import { z } from 'zod';
 import { meet as meetClient } from '@googleapis/meet';
-import { accountAliasSchema } from '../accounts.js';
+import { accountArgLive } from '../accounts.js';
 import { getClient } from '../client.js';
 import { handleGoogleApiError } from './_errors.js';
-const accountEnum = accountAliasSchema.optional();
-export function registerMeetTools(server) {
+export function registerMeetTools(server, deps = {}) {
+    // Per-registry, live account enum + injectable client: the schema follows
+    // the registry's account view at parse time, not a process-global default.
+    const accountEnum = accountArgLive(() => server.accountAliases()).optional();
+    const getClientFn = deps.getClientFn ?? getClient;
     // ─── Conference records (past meetings) ────────────────────────────────
     server.registerTool('meet_conference_records_list', {
         description: 'List past conference records (completed Meet sessions) the user has access to',
@@ -16,7 +19,7 @@ export function registerMeetTools(server) {
         },
     }, async ({ account, pageSize, pageToken, filter }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const meet = meetClient({ version: 'v2', auth });
             const res = await meet.conferenceRecords.list({
                 pageSize: pageSize ?? 20,
@@ -39,7 +42,7 @@ export function registerMeetTools(server) {
         },
     }, async ({ account, name }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const meet = meetClient({ version: 'v2', auth });
             const res = await meet.conferenceRecords.get({ name });
             return {
@@ -61,7 +64,7 @@ export function registerMeetTools(server) {
         },
     }, async ({ account, parent, pageSize, pageToken }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const meet = meetClient({ version: 'v2', auth });
             const res = await meet.conferenceRecords.recordings.list({
                 parent,
@@ -87,7 +90,7 @@ export function registerMeetTools(server) {
         },
     }, async ({ account, parent, pageSize, pageToken }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const meet = meetClient({ version: 'v2', auth });
             const res = await meet.conferenceRecords.transcripts.list({
                 parent,
@@ -112,7 +115,7 @@ export function registerMeetTools(server) {
         },
     }, async ({ account, parent, pageSize, pageToken }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const meet = meetClient({ version: 'v2', auth });
             const res = await meet.conferenceRecords.transcripts.entries.list({
                 parent,
@@ -128,7 +131,7 @@ export function registerMeetTools(server) {
         }
     });
 }
-function handleMeetError(error, account) {
+export function handleMeetError(error, account) {
     return handleGoogleApiError(error, account, {
         scope: 'Meet needs the meetings.space.readonly scope and the Google Meet API enabled in Cloud Console. Confirm both for this account.',
         resource: `Meet denied this conference record to "${account}". Meet exposes records only to the organizer or a participant, so check which account hosted the meeting.`,

package/dist/tools/searchconsole.d.ts

@@ -1,2 +1,3 @@
 import type { ToolRegistry } from '../registry.js';
-export declare function registerSearchConsoleTools(server: ToolRegistry): void;
+import { type CuratedToolDeps } from '../client.js';
+export declare function registerSearchConsoleTools(server: ToolRegistry, deps?: CuratedToolDeps): void;