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

package/dist/doctor.js

@@ -5,8 +5,11 @@ import { getAccountSet } from './accounts.js';
 import { deriveAccountHealth } from './tools/accounts-tool.js';
 import { peekMasterKeyProvenance, deleteMasterKeyMaterial } from './master-key.js';
 import { hasToken } from './token-store.js';
-import { configDir } from './config-file.js';
+import { configDir, loadConfigFile } from './config-file.js';
+import { envValueSource } from './env-load.js';
+import { describeMetricsDir, resolveUsageMetrics, sourceLabel } from './usage-metrics.js';
 import { probeApiEnablement } from './api-probe.js';
+import { safeMessage, stringifyEnvelope } from './tools/_errors.js';
 import { resolveHttpConfig, HttpConfigError } from './http-config.js';
 import { parseOwnerEmails } from './http-transport.js';
 const MIN_NODE_MAJOR = 22;
@@ -114,8 +117,24 @@ function sectionConfig(deps, set) {
             hint = (hint ? `${hint} ` : '') + `Move it: \`mv ${envFile} ${target}\`.`;
         }
     }
+    lines.push(usageMetricsStatusLine(deps.env));
     return { id: 2, title: 'Config', verdict, lines, ...(hint ? { hint } : {}), ...(slug ? { slug } : {}) };
 }
+/** One line, state AND source, so the people being measured can see both
+ * here and in `diagnose` (metrics spec section 2). Read-only. */
+export function usageMetricsStatusLine(env) {
+    const envSrc = envValueSource('GOOGLE_USAGE_METRICS');
+    let configValue;
+    try {
+        configValue = loadConfigFile(undefined, 'throw')?.usageMetrics;
+    }
+    catch { /* invalid config is section 2's business, not this line's */ }
+    const state = resolveUsageMetrics(env, configValue, envSrc?.kind === 'file' ? envSrc.file : undefined);
+    if (!state.enabled)
+        return `local usage metrics: off ${sourceLabel(state.source)}`;
+    const d = describeMetricsDir(env);
+    return `local usage metrics: on ${sourceLabel(state.source)} -> ${d.dir} (${d.files} files, ${d.kb} KB)`;
+}
 function sectionKeys(deps, aliases) {
     const provenance = deps.masterKeyProvenance();
     const tokensExist = deps.anyTokensExist(aliases);
@@ -338,9 +357,14 @@ export function exitCodeFor(report, strict) {
     return 0;
 }
 /** Agent-callable structured health report (read-only). Mirrors `doctor`'s
- * engine; NOT alwaysLoad (the agent asks for it when diagnosing). */
+ * engine. Registered as a META tool, like `account_list`: it introspects this
+ * server rather than Google data, and as a normal tool it became a service of
+ * its own with no `{service}_discover` to reveal it (discover tools are built
+ * from already-registered services, and this runs after that), so it was
+ * advertised only once something else expanded the surface. The README sends
+ * people here when they are stuck, so it has to be findable. */
 export function registerDiagnoseTool(registry) {
-    registry.registerTool('diagnose', {
+    registry.registerMeta('diagnose', {
         annotations: { readOnlyHint: true, openWorldHint: true },
         description: 'Health report for this server: runtime, config, keys, per-account token status, scope grants, and API enablement. Read-only; returns copy-pasteable fixes for anything wrong. Call this to diagnose auth/config failures.',
         inputSchema: {},
@@ -350,7 +374,11 @@ export function registerDiagnoseTool(registry) {
             return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
         }
         catch (e) {
-            return { content: [{ type: 'text', text: JSON.stringify({ error: 'diagnose_failed', message: e?.message ?? String(e) }) }], isError: true };
+            return { content: [{ type: 'text', text: stringifyEnvelope({
+                            error: 'diagnose_failed',
+                            message: safeMessage(e),
+                            retriable: false,
+                        }) }], isError: true };
         }
     });
 }

package/dist/env-load.d.ts

@@ -9,3 +9,14 @@ export interface EnvLoadPaths {
     configDir?: string;
 }
 export declare function loadEnvFiles(paths?: EnvLoadPaths): EnvLoadResult;
+/**
+ * Which layer supplied `key`: the real process env, or the first loaded .env
+ * file defining it (autoload never overwrites, so first wins). undefined when
+ * the key is unset. Powers self-announcing enablement sources (usage metrics).
+ */
+export declare function envValueSource(key: string): {
+    kind: 'process';
+} | {
+    kind: 'file';
+    file: string;
+} | undefined;

package/dist/env-load.js

@@ -1,4 +1,4 @@
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
@@ -48,5 +48,27 @@ export function loadEnvFiles(paths = {}) {
     }
     for (const [k, v] of boot)
         process.env[k] = v;
+    lastLoad = { bootKeys: new Set(boot.keys()), loaded };
     return { loaded, searched: candidates };
 }
+let lastLoad;
+/**
+ * Which layer supplied `key`: the real process env, or the first loaded .env
+ * file defining it (autoload never overwrites, so first wins). undefined when
+ * the key is unset. Powers self-announcing enablement sources (usage metrics).
+ */
+export function envValueSource(key) {
+    if (process.env[key] === undefined)
+        return undefined;
+    if (!lastLoad || lastLoad.bootKeys.has(key))
+        return { kind: 'process' };
+    const re = new RegExp(`^\\s*${key}\\s*=`, 'm');
+    for (const p of lastLoad.loaded) {
+        try {
+            if (re.test(readFileSync(p, 'utf-8')))
+                return { kind: 'file', file: p };
+        }
+        catch { /* file vanished since load: fall through */ }
+    }
+    return { kind: 'process' };
+}

package/dist/executor.js

@@ -1,7 +1,9 @@
 import { getClient } from './client.js';
+import { sliceEncoded } from './trim.js';
 import { expandPath, isGoogleApiUrl } from './discovery-client.js';
 import { handleGoogleApiError } from './tools/_errors.js';
 import { scopeHintForMethod } from './scope-observability.js';
+import { checkOutboundForMethod } from './outbound-allowlist.js';
 export const MAX_RESPONSE_CHARS = 100_000;
 export function jsonResult(payload, isError = false) {
     const base = { content: [{ type: 'text', text: JSON.stringify(payload) }] };
@@ -29,6 +31,11 @@ export function resolveRequestBody(httpMethod, body) {
     return body ?? undefined;
 }
 export async function executeApiMethod(method, args, deps = {}) {
+    // Outbound allowlist: no-op when off; with it active, structured bodies are
+    // inspected for recipient fields and raw-compose methods are refused.
+    const outbound = checkOutboundForMethod(method.id, args.body, args.account);
+    if (outbound)
+        return outbound;
     if (args.queryParams?.alt === 'media') {
         return jsonResult({
             error: 'binary_unsupported',
@@ -82,10 +89,14 @@ export async function executeApiMethod(method, args, deps = {}) {
         });
         const text = JSON.stringify(res.data ?? null);
         if (text.length > MAX_RESPONSE_CHARS) {
+            // Budget the ENCODED head: jsonResult re-stringifies it, so every quote
+            // and backslash inside doubles. Slicing raw characters made the emitted
+            // result exceed the cap this tool advertises, by up to 15 percent on a
+            // quote-dense listing.
             return jsonResult({
                 truncated: true,
                 totalChars: text.length,
-                head: text.slice(0, MAX_RESPONSE_CHARS),
+                head: sliceEncoded(text, MAX_RESPONSE_CHARS),
                 hint: 'Narrow the request (fields mask, pageSize) to get complete JSON.',
             });
         }

package/dist/fanout.js

@@ -1,21 +1,33 @@
 import { z } from 'zod';
-import { ACCOUNTS, getAccountSet } from './accounts.js';
+import { ACCOUNTS, getAccountSet, unknownAliasMessage } from './accounts.js';
 export const CSV_RE = /^[a-zA-Z0-9_-]+(\s*,\s*[a-zA-Z0-9_-]+)+$/;
 const FANOUT_CONCURRENCY = 5;
 export function fanoutAccountField(description) {
     const csvExample = ACCOUNTS.length > 1 ? `; or a CSV subset like "${ACCOUNTS.slice(0, 2).join(',')}"` : '';
+    // The union's OWN error only fires when every branch aborts at the type
+    // check (a non-string). For a string, zod surfaces the single non-aborted
+    // branch verbatim, which is the CSV regex, so a mistyped alias used to read
+    // as "Invalid string: must match pattern /^[a-zA-Z0-9_-]+(,...)/" and never
+    // named an alias. Hence the same message on BOTH.
+    const bad = () => unknownAliasMessage(ACCOUNTS, true);
     return z
         // '*' first so the tuple is statically non-empty even when ACCOUNTS is empty
         // (a fresh install): z.enum requires [string, ...string[]].
-        .union([z.enum(['*', ...ACCOUNTS]), z.string().regex(CSV_RE)])
+        .union([z.enum(['*', ...ACCOUNTS]), z.string().regex(CSV_RE, { error: bad })], { error: bad })
         .optional()
         .describe(`${description}; "*" = all accounts${csvExample}; omit for the default account`);
 }
 export function parseAccountSelector(value, accounts = getAccountSet().aliases) {
     if (value === '*')
         return { ok: true, fanout: true, aliases: [...accounts] };
-    if (!value.includes(','))
-        return { ok: true, fanout: false, aliases: [value] };
+    // A single alias used to skip validation entirely and reach getClient, whose
+    // throw landed on the mapper's floor as an unclassified upstream_error. Same
+    // check and same envelope wherever the alias was typed.
+    if (!value.includes(',')) {
+        return accounts.includes(value)
+            ? { ok: true, fanout: false, aliases: [value] }
+            : { ok: false, invalid: [value] };
+    }
     const seen = new Set();
     const aliases = [];
     const invalid = [];
@@ -30,7 +42,9 @@ export function parseAccountSelector(value, accounts = getAccountSet().aliases)
     }
     if (invalid.length > 0)
         return { ok: false, invalid };
-    return { ok: true, fanout: aliases.length > 1, aliases };
+    // Keyed on the CSV FORM, not the deduped count: "a,a" asked for the merged
+    // multi-account envelope and used to get a bare single-account payload.
+    return { ok: true, fanout: true, aliases };
 }
 export function invalidAccountsResult(invalid, accounts = getAccountSet().aliases) {
     return {
@@ -40,8 +54,9 @@ export function invalidAccountsResult(invalid, accounts = getAccountSet().aliase
                 text: JSON.stringify({
                     error: 'validation_error',
                     message: `Unknown account alias(es): ${invalid.join(', ')}.`,
-                    hint: `Valid aliases: ${accounts.join(', ')}; or "*" for all accounts.`,
+                    hint: unknownAliasMessage(accounts, true),
                     retriable: false,
+                    account: invalid.join(','),
                 }),
             },
         ],
@@ -82,7 +97,27 @@ export async function runFanout(handler, args, aliases) {
     };
     await Promise.all(Array.from({ length: Math.min(FANOUT_CONCURRENCY, aliases.length) }, () => worker()));
     const failed = results.filter((r) => !r.ok).length;
+    if (failed === results.length && results.length > 0) {
+        // Every account failed, so this IS an error result, and used to carry
+        // `isError` with no top-level error, hint or retriable: the agent saw a
+        // successful-looking object flagged as an error, and metrics bucketed it
+        // as `other`. Hoist a real envelope, keeping the per-account detail.
+        const slugs = [...new Set(results.map((r) => r.error?.error ?? 'internal'))];
+        const hints = [...new Set(results.map((r) => r.error?.hint).filter(Boolean))];
+        const retriable = results.every((r) => r.error?.retriable === true);
+        return {
+            content: [{ type: 'text', text: JSON.stringify({
+                        error: 'fanout_failed',
+                        message: `All ${results.length} accounts failed: ${slugs.join(', ')}. Per-account detail is in results.`,
+                        hint: hints.length === 1 ? hints[0] : 'Each entry in results carries its own error and hint; they differ per account.',
+                        retriable,
+                        account: aliases.join(','),
+                        results,
+                        partial: true,
+                    }) }],
+            isError: true,
+        };
+    }
     const body = { results, partial: failed > 0 };
-    const out = { content: [{ type: 'text', text: JSON.stringify(body) }] };
-    return failed === results.length ? { ...out, isError: true } : out;
+    return { content: [{ type: 'text', text: JSON.stringify(body) }] };
 }

package/dist/http-transport.d.ts

@@ -1,6 +1,7 @@
+import type { McpServer, Transport } from "@modelcontextprotocol/server";
 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, type StrictArgOptions, type ValidationEnvelopeOptions } from './arg-normalize.js';
 export type AuthOutcome = {
     ok: true;
 } | {
@@ -28,6 +29,17 @@ 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;
+    /** Usage-metrics transport tap (metrics-tap.ts); absent = off. */
+    metricsTap?: (t: Transport) => Transport;
+    /** Wired identically on both transports so a schema rejection reads the same
+     * over stdio and over HTTP. */
+    validationEnvelope?: ValidationEnvelopeOptions;
+    /** Usage-metrics argfix observer, forwarded into arg normalization. */
+    onArgRename?: (tool: string, renames: number) => void;
+    /** Unknown-argument screening (arg-strict.ts); absent = off. */
+    strictArgs?: StrictArgOptions;
 }
 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

@@ -1,10 +1,10 @@
-// B12: the Streamable HTTP transport host (cc-transport-hosting T2/T3). Owns the
+import { NodeStreamableHTTPServerTransport } from "@modelcontextprotocol/node";
 // node:http server, the route table, the front guard (Host / Origin / DNS-rebind),
 // and the stateless per-request /mcp dispatch. The OAuth AS endpoints and Bearer
 // verification are a seam filled by B13 (oauth-authorization-server); B12 ships a
 // 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, withValidationEnvelope } 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.
@@ -160,7 +160,7 @@ export class HttpTransportHost {
         // the mounted AS routes), so the SDK's own DNS-rebind guard is disabled: its
         // exact-Host match is stricter than the front guard and would 403 valid
         // Hosts (double enforcement, differing rules).
-        const transport = new StreamableHTTPServerTransport({
+        const transport = new NodeStreamableHTTPServerTransport({
             sessionIdGenerator: undefined,
             enableJsonResponse: true,
             enableDnsRebindingProtection: false,
@@ -182,7 +182,13 @@ export class HttpTransportHost {
                 timer = setTimeout(() => resolve('timeout'), deadlineMs);
                 timer.unref?.();
             });
-            await this.opts.server.connect(transport);
+            // Same composition as the stdio leg: the envelope rewrite is innermost,
+            // so the tap above it still classifies the original validation prose.
+            const enveloped = withValidationEnvelope(transport, this.opts.validationEnvelope ?? {});
+            const tapped = this.opts.metricsTap ? this.opts.metricsTap(enveloped) : enveloped;
+            await this.opts.server.connect(this.opts.argShapeFor || this.opts.strictArgs
+                ? withArgNormalization(tapped, this.opts.argShapeFor ?? (() => undefined), this.opts.log, this.opts.onArgRename, this.opts.strictArgs)
+                : tapped);
             // 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

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 // First import: triggers accounts.js module load (env files + registry) before
 // anything else. Named to also pull the server-only empty-registry guard (BR-4).
-import { assertServerAccountsConfigured } from './accounts.js';
+import { assertServerAccountsConfigured, getAccountSet } from './accounts.js';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+import { McpServer } from "@modelcontextprotocol/server";
 import { GENERATED_SERVICES } from './tools/generated/index.js';
-import { GENERATED_GATES, SERVICES } from './services.js';
-import { ToolRegistry } from './registry.js';
+import { GENERATED_GATES, SERVICES, unknownToolMessage } from './services.js';
+import { ToolRegistry, resolveDiscoveryMode } from './registry.js';
 import { registerDiscoverTools } from './discover.js';
 import { registerEscapeTools } from './tools/google-api.js';
 import { registerAccountTools } from './tools/accounts-tool.js';
@@ -20,12 +20,31 @@ 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, withValidationEnvelope } from './arg-normalize.js';
+import { unknownArgMode } from './arg-strict.js';
+import { envValueSource } from './env-load.js';
+import { loadConfigFile } from './config-file.js';
+import { initUsageMetrics, resolveUsageMetrics, sourceLabel } from './usage-metrics.js';
 applyNetTuning();
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(path.resolve(__dirname, '..', 'package.json'), 'utf-8'));
-function buildRegistry(server, ctx, mode) {
+/** Unknown-argument screening options, or undefined when the feature is off.
+ * Shared by both transports so a mistyped argument behaves identically. */
+function strictArgOptions(registry, metrics) {
+    const mode = unknownArgMode();
+    if (mode === 'off')
+        return undefined;
+    return {
+        mode,
+        declaredFor: (tool) => registry.declaredKeys(tool),
+        siblingsFor: (tool, keys) => registry.siblingSpellings(tool, keys),
+        unknownTool: (name) => unknownToolMessage(registry, name),
+        onDrop: metrics ? (tool, keys) => metrics.recordArgDrop(tool, keys) : undefined,
+    };
+}
+function buildRegistry(server, ctx, mode, metrics = null) {
     const policy = ctx.policy;
-    const registry = new ToolRegistry(server, policy, mode);
+    const registry = new ToolRegistry(server, policy, mode, metrics);
     const toolsets = getToolsets();
     if (toolsets !== 'all') {
         const known = new Set([...SERVICES.map((s) => s.name), ...GENERATED_SERVICES.map((s) => s.name)]);
@@ -99,6 +118,22 @@ async function main() {
         process.exitCode = await runResetCli(process.argv);
         return;
     }
+    if (process.argv.includes('metrics')) {
+        const { runMetricsCli } = await import('./metrics-cli.js');
+        const { GENERATED_METHOD_TOOLS, CURATED_METHOD_IDS } = await import('./tools/generated/method-map.js');
+        const envSrc = envValueSource('GOOGLE_USAGE_METRICS');
+        let configValue;
+        try {
+            configValue = loadConfigFile(undefined, 'throw')?.usageMetrics;
+        }
+        catch { /* an invalid config never blocks reading local metrics files */ }
+        const state = resolveUsageMetrics(process.env, configValue, envSrc?.kind === 'file' ? envSrc.file : undefined);
+        process.exitCode = runMetricsCli(process.argv, {
+            enabled: state.enabled,
+            promotion: { methodMap: GENERATED_METHOD_TOOLS, curatedIds: CURATED_METHOD_IDS },
+        });
+        return;
+    }
     if (process.argv.includes('write-client-config')) {
         const { runWriteClientConfigCli } = await import('./client-config.js');
         process.exitCode = await runWriteClientConfigCli(process.argv);
@@ -182,14 +217,68 @@ async function main() {
     }
     const wantStdio = httpCfg.transport === 'stdio' || httpCfg.transport === 'both';
     const wantHttp = transportIncludesHttp(httpCfg.transport);
+    // Local usage metrics: fail-closed resolve, self-announcing source, null
+    // when off (no wrapper, no dir, nothing initializes). One instance per
+    // transport so `boots` keys stay honest under `both`.
+    const envSrc = envValueSource('GOOGLE_USAGE_METRICS');
+    const metricsState = resolveUsageMetrics(process.env, loadConfigFile()?.usageMetrics, envSrc?.kind === 'file' ? envSrc.file : undefined);
+    if (metricsState.warning)
+        process.stderr.write(metricsState.warning);
+    const metricsInstances = [];
+    const initMetricsFor = (transport, mode) => {
+        const m = initUsageMetrics(metricsState, { version: pkg.version, mode, transport });
+        if (m) {
+            metricsInstances.push(m);
+            process.stderr.write(`local usage metrics: on ${sourceLabel(metricsState.source)} -> ${m.statusLine()}\n`);
+        }
+        return m;
+    };
+    if (!metricsState.enabled && metricsState.source.kind !== 'default') {
+        process.stderr.write(`local usage metrics: off ${sourceLabel(metricsState.source)}\n`);
+    }
+    const flushMetrics = () => { for (const m of metricsInstances)
+        m.shutdown(); };
+    process.on('exit', flushMetrics);
+    if (metricsState.enabled) {
+        for (const sig of ['SIGTERM', 'SIGINT']) {
+            process.once(sig, () => {
+                flushMetrics();
+                // stdio has no other signal handler; preserve terminate-on-signal.
+                if (!wantHttp)
+                    process.exit(sig === 'SIGINT' ? 130 : 143);
+            });
+        }
+    }
     // Build one McpServer + registry per transport at boot (P1 / BV gap #4:
     // never rebuilt per request); `both` runs the two concurrently.
     if (wantStdio) {
         const server = new McpServer({ name: 'mcp-google-multi', version: pkg.version });
-        const registry = buildRegistry(server, buildIdentityContext(process.env, { transport: 'stdio' }));
+        const stdioMetrics = initMetricsFor('stdio', resolveDiscoveryMode());
+        const registry = buildRegistry(server, buildIdentityContext(process.env, { transport: 'stdio' }), undefined, stdioMetrics);
         registry.installListHandler();
         registerSetupPrompt(server);
-        await server.connect(new StdioServerTransport());
+        // Outbound runs outermost-first, so the composition is deliberate: the
+        // envelope rewrite is INNERMOST (last to touch the frame), the tap sits
+        // above it (classifying the ORIGINAL validation prose), arg normalization
+        // outermost. The tap only counts outbound JSON-RPC error frames (no
+        // handler ran) plus id->tool names.
+        let transport = withValidationEnvelope(new StdioServerTransport(), {
+            isKnownTool: (n) => registry.hasTool(n),
+            defaultAccount: () => getAccountSet().defaultAccount,
+        });
+        if (stdioMetrics) {
+            const { tapUsageMetrics } = await import('./metrics-tap.js');
+            transport = tapUsageMetrics(transport, stdioMetrics, (n) => registry.hasTool(n));
+        }
+        const strictStdio = strictArgOptions(registry, stdioMetrics);
+        await server.connect(argNormalizationEnabled() || strictStdio
+            ? withArgNormalization(transport, 
+            // Gated exactly as the HTTP leg gates `argShapeFor`. Passing the
+            // shape unconditionally made stdio rename keys while
+            // GOOGLE_ARG_NORMALIZE=off, so the same call succeeded on stdio
+            // and failed on HTTP once screening rejects.
+            argNormalizationEnabled() ? (n) => registry.argShape(n) : () => undefined, undefined, stdioMetrics ? (tool, n) => stdioMetrics.recordArgFix(tool, n) : undefined, strictStdio)
+            : transport);
     }
     if (wantHttp) {
         const { HttpTransportHost, parseOwnerEmails } = await import('./http-transport.js');
@@ -206,7 +295,8 @@ async function main() {
             process.stderr.write(`GOOGLE_DISCOVERY="${configuredMode}" is ignored over HTTP; the stateless transport forces "curated".\n`);
         }
         const httpServer = new McpServer({ name: 'mcp-google-multi', version: pkg.version });
-        const registry = buildRegistry(httpServer, buildIdentityContext(process.env, { transport: 'http' }), 'curated');
+        const httpMetrics = initMetricsFor('http', 'curated');
+        const registry = buildRegistry(httpServer, buildIdentityContext(process.env, { transport: 'http' }), 'curated', httpMetrics);
         registry.installListHandler();
         registerSetupPrompt(httpServer);
         // B13: mount the OAuth 2.1 AS (legs A + B) + the Bearer authenticator.
@@ -272,6 +362,11 @@ async function main() {
         // re-auth link into the AS's alias_reauth flow instead of a stdio CLI hint.
         const { setHttpReauthBase } = await import('./reauth-hint.js');
         setHttpReauthBase(httpCfg.publicUrl);
+        let httpTap;
+        if (httpMetrics) {
+            const { tapUsageMetrics } = await import('./metrics-tap.js');
+            httpTap = (t) => tapUsageMetrics(t, httpMetrics, (n) => registry.hasTool(n));
+        }
         const host = new HttpTransportHost({
             server: httpServer,
             config: httpCfg,
@@ -280,6 +375,14 @@ async function main() {
             authenticate: authServer.authenticate,
             routes: authServer.routes,
             log: (l) => process.stderr.write(`[http] ${l}\n`),
+            argShapeFor: argNormalizationEnabled() ? (n) => registry.argShape(n) : undefined,
+            metricsTap: httpTap,
+            validationEnvelope: {
+                isKnownTool: (n) => registry.hasTool(n),
+                defaultAccount: () => getAccountSet().defaultAccount,
+            },
+            onArgRename: httpMetrics ? (tool, n) => httpMetrics.recordArgFix(tool, n) : undefined,
+            strictArgs: strictArgOptions(registry, httpMetrics),
         });
         await host.start();
         process.stderr.write(`HTTP transport listening on http://${httpCfg.host}:${httpCfg.port} (public ${httpCfg.publicUrl})\n`);

package/dist/metrics-cli.d.ts

@@ -0,0 +1,21 @@
+import { type DayAgg } from './usage-metrics.js';
+export interface PromotionData {
+    methodMap: Record<string, string>;
+    curatedIds: readonly string[];
+}
+export interface MetricsCliDeps {
+    enabled: boolean;
+    promotion: PromotionData;
+    env?: NodeJS.ProcessEnv;
+    out?: (line: string) => void;
+}
+interface PromotionRow {
+    methodId: string;
+    tool?: string;
+    calls: number;
+    kind: 'curation-candidate' | 'visibility-failure' | 'generation-gap';
+}
+/** The promotion-queue view: ranked evidence, a human decides (spec section 5). */
+export declare function classifyPromotion(merged: DayAgg, data: PromotionData): PromotionRow[];
+export declare function runMetricsCli(argv: string[], deps: MetricsCliDeps): number;
+export {};