mcp-google-multi 6.0.0-alpha.9 → 6.0.0-beta.1

package/README.md

@@ -7,7 +7,7 @@ The most complete **local Google Workspace MCP server**: Gmail, Drive, Calendar,
 - 🧰 **Exhaustive** — 874 tools across 28 services + an escape hatch for anything else → [COVERAGE.md](./COVERAGE.md)
 - 🔑 **Multi-account** — drive any number of Google accounts by alias, or fan one call out across all of them
 - 🔒 **Private by design** — your own OAuth app, tokens encrypted at rest (AES-256-GCM), writes deny-by-default, no telemetry, no metering — it talks only to Google
-- 🌐 **Local or remote** — runs locally over stdio, or self-hosted over HTTP with its own built-in OAuth 2.1 server (Claude Code's `/mcp` login and the claude.ai connector, zero custom UI) → [remote setup](./docs/http-setup.md)
+- 🌐 **Local or remote** — runs locally over stdio, or self-hosted over HTTP with its own built-in OAuth 2.1 server (Claude Code's `/mcp` login and the claude.ai connector, zero custom UI). Pull-and-up Docker Compose with optional automatic HTTPS → [remote setup](./docs/http-setup.md)
 - ✉️ **Built for real work** — send and read email in Markdown with attachments and one-call replies, an interactive setup wizard with a `doctor` self-check, and per-account scope profiles → [features tour](./docs/features.md)
 
 ## Quick setup

package/dist/arg-normalize.d.ts

@@ -0,0 +1,19 @@
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+export declare function argNormalizationEnabled(env?: NodeJS.ProcessEnv): boolean;
+/** Declared scalar kind per schema key; drives value coercion on RENAMED keys
+ * only. Clients string-encode values for keys absent from the advertised
+ * schema, so a renamed key almost always arrives as a string — without
+ * coercion the rename would just move the -32602 from the key to the value. */
+export type ArgKind = 'number' | 'boolean' | 'other';
+export type ArgShape = ReadonlyMap<string, ArgKind>;
+export declare function normalizeCallArguments(shape: ArgShape, args: Record<string, unknown>): {
+    args: Record<string, unknown>;
+    renamed: [string, string][];
+};
+export declare function normalizeMessage(msg: JSONRPCMessage, shapeFor: (tool: string) => ArgShape | undefined, log?: (line: string) => void): JSONRPCMessage;
+/** Wrap a server-side transport so tools/call argument keys are normalized
+ * before the SDK validates them. The Protocol assigns `onmessage` during
+ * connect(); the interceptor lives in that setter, so the wrapper works
+ * identically for stdio and (per-request, stateless) HTTP transports. */
+export declare function withArgNormalization(transport: Transport, shapeFor: (tool: string) => ArgShape | undefined, log?: (line: string) => void): Transport;

package/dist/arg-normalize.js

@@ -0,0 +1,90 @@
+// Wire-level tools/call argument normalization. Clients (LLMs) recurringly
+// snake_case a camelCase parameter (thread_id for threadId) and burn a retry
+// on the -32602. A schema-level fix is off the table: SDK 1.x advertises an
+// EMPTY input schema for any non-object wrapper (pipe/preprocess), so the
+// only seam that keeps tools/list intact is the JSON-RPC message itself —
+// which is versioned MCP spec, stabler than any SDK internal. The rename is
+// provably lossless: it fires only when the sent key is NOT in the tool's
+// schema, its camelCase twin IS, and that twin was not also sent.
+export function argNormalizationEnabled(env = process.env) {
+    return !/^(0|false|off|no)$/i.test((env.GOOGLE_ARG_NORMALIZE ?? '').trim());
+}
+const snakeToCamel = (key) => key.replace(/_([a-z0-9])/g, (_m, c) => c.toUpperCase());
+function coerceRenamedValue(value, kind) {
+    if (typeof value !== 'string')
+        return value;
+    const v = value.trim();
+    if (kind === 'number' && /^-?\d+(\.\d+)?$/.test(v))
+        return Number(v);
+    if (kind === 'boolean' && /^(true|false)$/i.test(v))
+        return v.toLowerCase() === 'true';
+    return value;
+}
+export function normalizeCallArguments(shape, args) {
+    const renamed = [];
+    let out;
+    for (const key of Object.keys(args)) {
+        if (shape.has(key) || !key.includes('_'))
+            continue;
+        const camel = snakeToCamel(key);
+        if (camel !== key && shape.has(camel) && !(camel in args)) {
+            out ??= { ...args };
+            out[camel] = coerceRenamedValue(out[key], shape.get(camel));
+            delete out[key];
+            renamed.push([key, camel]);
+        }
+    }
+    return { args: out ?? args, renamed };
+}
+export function normalizeMessage(msg, shapeFor, log = (l) => process.stderr.write(`${l}\n`)) {
+    const m = msg;
+    if (m.method !== 'tools/call' || typeof m.params?.name !== 'string')
+        return msg;
+    const args = m.params.arguments;
+    if (!args || typeof args !== 'object' || Array.isArray(args))
+        return msg;
+    const shape = shapeFor(m.params.name);
+    if (!shape)
+        return msg;
+    const { args: normalized, renamed } = normalizeCallArguments(shape, args);
+    if (renamed.length === 0)
+        return msg;
+    // Key names only — argument VALUES never reach the log.
+    log(`[args] ${m.params.name}: ${renamed.map(([f, t]) => `${f} -> ${t}`).join(', ')}`);
+    return {
+        ...msg,
+        params: { ...m.params, arguments: normalized },
+    };
+}
+/** Wrap a server-side transport so tools/call argument keys are normalized
+ * before the SDK validates them. The Protocol assigns `onmessage` during
+ * connect(); the interceptor lives in that setter, so the wrapper works
+ * identically for stdio and (per-request, stateless) HTTP transports. */
+export function withArgNormalization(transport, shapeFor, log) {
+    const wrapper = {
+        start: () => transport.start(),
+        send: (message, options) => transport.send(message, options),
+        close: () => transport.close(),
+    };
+    Object.defineProperty(wrapper, 'onmessage', {
+        get: () => transport.onmessage,
+        set: (handler) => {
+            transport.onmessage = handler
+                ? (message, extra) => handler(normalizeMessage(message, shapeFor, log), extra)
+                : undefined;
+        },
+    });
+    for (const prop of ['onclose', 'onerror']) {
+        Object.defineProperty(wrapper, prop, {
+            get: () => transport[prop],
+            set: (v) => {
+                transport[prop] = v;
+            },
+        });
+    }
+    Object.defineProperty(wrapper, 'sessionId', { get: () => transport.sessionId });
+    if (transport.setProtocolVersion) {
+        wrapper.setProtocolVersion = (v) => transport.setProtocolVersion(v);
+    }
+    return wrapper;
+}

package/dist/http-transport.d.ts

@@ -1,6 +1,7 @@
 import { type IncomingMessage, type ServerResponse } from 'node:http';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { HttpConfig } from './http-config.js';
+import { type ArgShape } from './arg-normalize.js';
 export type AuthOutcome = {
     ok: true;
 } | {
@@ -28,6 +29,8 @@ export interface HttpHostOptions {
     /** Deadline for a single /mcp dispatch; a hung handler past this releases the
      * shared lock instead of wedging the transport (default 120s). */
     dispatchTimeoutMs?: number;
+    /** tools/call argument-key normalization lookup (arg-normalize.ts); absent = off. */
+    argShapeFor?: (tool: string) => ArgShape | undefined;
 }
 export declare function parseOwnerEmails(env?: NodeJS.ProcessEnv): string[];
 /** Front guard: an Origin, if present, must be allowlisted; a Host must be

package/dist/http-transport.js

@@ -5,6 +5,7 @@
 // loopback-owner authenticator so the local-HTTP model works before the AS lands.
 import { createServer } from 'node:http';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { withArgNormalization } from './arg-normalize.js';
 // A hung handler that keeps the connection open would otherwise hold the global
 // serialize() lock forever. Generous by default so slow-but-valid calls (large
 // Drive exports, fan-out) still finish; the point is only to guarantee release.
@@ -182,7 +183,7 @@ export class HttpTransportHost {
                 timer = setTimeout(() => resolve('timeout'), deadlineMs);
                 timer.unref?.();
             });
-            await this.opts.server.connect(transport);
+            await this.opts.server.connect(this.opts.argShapeFor ? withArgNormalization(transport, this.opts.argShapeFor, this.opts.log) : transport);
             // Reflect the dispatch into a non-rejecting arm: if the deadline wins the
             // race, an orphaned handler settling later must not surface as an unhandled
             // rejection — but a genuine dispatch error still propagates (rethrown below).

package/dist/index.js

@@ -20,6 +20,7 @@ import { isAllowed, describePolicy } from './write-control.js';
 import { buildIdentityContext } from './identity.js';
 import { registerSetupPrompt } from './setup-prompt.js';
 import { applyNetTuning } from './net-tuning.js';
+import { argNormalizationEnabled, withArgNormalization } from './arg-normalize.js';
 applyNetTuning();
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(path.resolve(__dirname, '..', 'package.json'), 'utf-8'));
@@ -189,7 +190,8 @@ async function main() {
         const registry = buildRegistry(server, buildIdentityContext(process.env, { transport: 'stdio' }));
         registry.installListHandler();
         registerSetupPrompt(server);
-        await server.connect(new StdioServerTransport());
+        const stdioTransport = new StdioServerTransport();
+        await server.connect(argNormalizationEnabled() ? withArgNormalization(stdioTransport, (n) => registry.argShape(n)) : stdioTransport);
     }
     if (wantHttp) {
         const { HttpTransportHost, parseOwnerEmails } = await import('./http-transport.js');
@@ -280,6 +282,7 @@ async function main() {
             authenticate: authServer.authenticate,
             routes: authServer.routes,
             log: (l) => process.stderr.write(`[http] ${l}\n`),
+            argShapeFor: argNormalizationEnabled() ? (n) => registry.argShape(n) : undefined,
         });
         await host.start();
         process.stderr.write(`HTTP transport listening on http://${httpCfg.host}:${httpCfg.port} (public ${httpCfg.publicUrl})\n`);

package/dist/registry.d.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import { type Policy } from './write-control.js';
+import type { ArgShape } from './arg-normalize.js';
 export type Cud = 'read' | 'create' | 'update' | 'delete';
 export type DiscoveryMode = 'lazy' | 'curated' | 'eager';
 export declare function resolveDiscoveryMode(env?: NodeJS.ProcessEnv): DiscoveryMode;
@@ -38,6 +39,7 @@ export declare class ToolRegistry {
     readonly registerTool: McpServer['registerTool'];
     private readonly revealed;
     private readonly jsonSchemaCache;
+    private readonly argShapeCache;
     private readonly compactOutput;
     private registeringMeta;
     /** Configured visibility mode (GOOGLE_DISCOVERY); default lazy = v5 exact. */
@@ -48,6 +50,9 @@ export declare class ToolRegistry {
     constructor(server: McpServer, policy: Policy, mode?: DiscoveryMode);
     registerMeta: McpServer['registerTool'];
     services(): string[];
+    /** Declared input-schema keys + scalar kinds for one tool (tools/call arg
+     * normalization; the kind drives value coercion on renamed keys). */
+    argShape(name: string): ArgShape | undefined;
     catalog(service: string, query?: string): CatalogOperation[];
     reveal(service: string): boolean;
     /** discover_all: advertise the full curated set at once. Idempotent. */

package/dist/registry.js

@@ -38,6 +38,23 @@ const SERVICE_OVERRIDES = {
 };
 // read tools that write local files — same savePath fanned across accounts would clobber
 const FANOUT_EXCLUDE = new Set(['gmail_download_attachment', 'drive_download', 'drive_export']);
+/** Unwrap optional/default/nullable to the declared scalar kind (zod 4 defs). */
+function scalarKindOf(field) {
+    let cur = field;
+    for (let i = 0; i < 4 && cur?._zod?.def; i++) {
+        const def = cur._zod.def;
+        if (def.type === 'number')
+            return 'number';
+        if (def.type === 'boolean')
+            return 'boolean';
+        if (def.type === 'optional' || def.type === 'default' || def.type === 'nullable') {
+            cur = def.innerType;
+            continue;
+        }
+        return 'other';
+    }
+    return 'other';
+}
 function isAccountEnum(field) {
     const def = field?._zod?.def;
     if (!def)
@@ -69,6 +86,7 @@ export class ToolRegistry {
     registerTool;
     revealed = new Set();
     jsonSchemaCache = new Map();
+    argShapeCache = new Map();
     compactOutput = trimEnabled();
     registeringMeta = false;
     /** Configured visibility mode (GOOGLE_DISCOVERY); default lazy = v5 exact. */
@@ -192,6 +210,21 @@ export class ToolRegistry {
     services() {
         return [...new Set(this.tools.filter((t) => !t.meta).map((t) => t.service))];
     }
+    /** Declared input-schema keys + scalar kinds for one tool (tools/call arg
+     * normalization; the kind drives value coercion on renamed keys). */
+    argShape(name) {
+        const cached = this.argShapeCache.get(name);
+        if (cached)
+            return cached;
+        const entry = this.tools.find((t) => t.name === name);
+        if (!entry)
+            return undefined;
+        const shape = new Map();
+        for (const [key, field] of Object.entries(entry.inputShape))
+            shape.set(key, scalarKindOf(field));
+        this.argShapeCache.set(name, shape);
+        return shape;
+    }
     catalog(service, query) {
         const q = query?.trim().toLowerCase();
         return this.tools

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-google-multi",
-  "version": "6.0.0-alpha.9",
+  "version": "6.0.0-beta.1",
   "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",
@@ -58,7 +58,8 @@
     "gen:discovery": "tsx scripts/fetch-discovery.ts",
     "gen:tools": "tsx scripts/gen-tools.ts",
     "gen:coverage": "tsx scripts/gen-coverage.ts",
-    "pack:mcpb": "mcpb pack . mcp-google-multi.mcpb"
+    "pack:mcpb": "mcpb pack . mcp-google-multi.mcpb",
+    "bundle": "esbuild dist/index.js --bundle --platform=node --format=esm --outfile=bundle/index.js --external:@napi-rs/keyring --banner:js=\"import{createRequire as __dockerCR}from'node:module';var require=__dockerCR(import.meta.url);\" --log-level=warning"
   },
   "dependencies": {
     "@googleapis/admin": "^37.0.0",
@@ -88,12 +89,14 @@
   "devDependencies": {
     "@anthropic-ai/mcpb": "^2.1.2",
     "@eslint/js": "^10.0.1",
+    "@semantic-release/exec": "^7.1.0",
     "@types/js-yaml": "^4.0.9",
     "@types/markdown-it": "^14.1.2",
     "@types/mime-types": "^3.0.1",
     "@types/node": "^22.20.1",
     "@types/nodemailer": "^8.0.1",
     "@types/turndown": "^5.0.6",
+    "esbuild": "^0.28.2",
     "eslint": "^10.2.1",
     "js-yaml": "^4.3.2",
     "semantic-release": "^25.0.3",