@plaud-ai/mcp 0.3.2 → 0.3.4

package/dist/{server-D3JKIARR.js → server-VVQEILKC.js}

@@ -1,9 +1,10 @@
 import {
+  normalizeMcpHost,
   registerTools
-} from "./chunk-XA77WLYF.js";
+} from "./chunk-XWDA3G2U.js";
 import {
   PlaudClient
-} from "./chunk-R5G6UXSI.js";
+} from "./chunk-D2JZW2TW.js";
 import {
   logger
 } from "./chunk-NPCCDRWQ.js";
@@ -12,12 +13,11 @@ import {
   httpRequestsInProgress,
   oauthTokenRefresh
 } from "./chunk-RUFCT6DQ.js";
-import "./chunk-MCKGQKYU.js";
 
 // src/http/server.ts
 import express from "express";
 import { createServer } from "http";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { createOAuthMetadata, mcpAuthRouter } from "@modelcontextprotocol/sdk/server/auth/router.js";
@@ -267,6 +267,15 @@ function validateMetadata(parsed, expectedClientIdUrl) {
 }
 
 // src/http/oauth-provider.ts
+function subFromJwt(token) {
+  if (!token) return void 0;
+  try {
+    const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64url").toString());
+    return typeof payload.sub === "string" ? payload.sub : void 0;
+  } catch {
+    return void 0;
+  }
+}
 var DEFAULT_TOKEN_URL = "https://platform.plaud.ai/developer/api/oauth/third-party/access-token";
 var DEFAULT_REFRESH_URL = "https://platform.plaud.ai/developer/api/oauth/third-party/access-token/refresh";
 var STATELESS_CODE_PREFIX = "pc1_";
@@ -287,6 +296,7 @@ var PlaudOAuthProvider = class extends ProxyOAuthServerProvider {
   _callbackUrl;
   _debugOAuthLogs;
   _cimdLoader;
+  _tracker;
   _registeredClients = /* @__PURE__ */ new Map();
   // HMAC secret used to sign DCR-issued client_ids so we can recover them
   // across container restarts without persistent storage. See verifyAndRecover.
@@ -346,6 +356,7 @@ var PlaudOAuthProvider = class extends ProxyOAuthServerProvider {
     this._callbackUrl = options.callbackUrl;
     this._debugOAuthLogs = options.debugOAuthLogs ?? false;
     this._cimdLoader = options.cimdLoader;
+    this._tracker = options.tracker;
     const secret = process.env["PLAUD_DCR_HMAC_SECRET"];
     if (secret && secret.length >= 32) {
       this._clientIdSecret = Buffer.from(secret, "utf-8");
@@ -380,6 +391,14 @@ var PlaudOAuthProvider = class extends ProxyOAuthServerProvider {
           client_id_issued_at: Math.floor(Date.now() / 1e3)
         };
         this._registeredClients.set(full.client_id, full);
+        this._tracker?.track({
+          name: "mcp.dcr_registration_success",
+          actorType: "service",
+          params: {
+            dcr_client_id: full.client_id,
+            ...normalizeMcpHost(client.client_name) ? { mcp_host: normalizeMcpHost(client.client_name) } : {}
+          }
+        });
         if (this._debugOAuthLogs) {
           logger.info({
             event: "oauth_client_registered",
@@ -591,11 +610,45 @@ var PlaudOAuthProvider = class extends ProxyOAuthServerProvider {
     });
     res.redirect(target.toString());
   }
+  /**
+   * Resolve the REAL Plaud user_id (the `/users/current` `id` field) from a fresh
+   * access token — the same id the CLI/stdio telemetry and the Plaud app use, so
+   * warehouse auth.* events join with tool events, subscription and frontend data.
+   * The JWT `sub` is only an OAuth pseudo-id (`client_user_…`), so we resolve via
+   * the API. Best-effort: on any failure fall back to the JWT sub, so the event
+   * still carries a stable id and the auth flow is never blocked.
+   */
+  async resolveRealUserId(accessToken) {
+    if (!accessToken) return void 0;
+    try {
+      const client = new PlaudClient({
+        clientId: this._plaudClientId,
+        clientSecret: "",
+        redirectUri: "",
+        apiBase: this._plaudApiBase,
+        staticToken: accessToken
+      });
+      const user = await client.getCurrentUser();
+      const id = typeof user?.id === "string" ? user.id : void 0;
+      return id ?? subFromJwt(accessToken);
+    } catch {
+      return subFromJwt(accessToken);
+    }
+  }
   // Override to use PKCE public-client flow — no Basic auth, client_id sent in body.
-  async exchangeAuthorizationCode(_client, authorizationCode, codeVerifier, _redirectUri, resource) {
+  async exchangeAuthorizationCode(client, authorizationCode, codeVerifier, _redirectUri, resource) {
+    const failedAuth = (failureKind) => {
+      this._tracker?.track({
+        name: "auth.oauth_callback_error",
+        actorType: "user",
+        distinctId: client.client_id,
+        params: { failure_kind: failureKind }
+      });
+    };
     const pendingCode = this.decodeAuthorizationCode(authorizationCode);
     if (!pendingCode) {
       logger.warn({ event: "oauth_authorization_code_unknown", code_len: authorizationCode.length });
+      failedAuth("business");
       throw new InvalidGrantError("Unknown or expired authorization code");
     }
     if (pendingCode.resource && resource && resource.href !== pendingCode.resource) {
@@ -604,6 +657,7 @@ var PlaudOAuthProvider = class extends ProxyOAuthServerProvider {
         expected_resource: pendingCode.resource,
         received_resource: resource.href
       });
+      failedAuth("business");
       throw new InvalidGrantError("Mismatched resource");
     }
     const body = {
@@ -641,18 +695,32 @@ var PlaudOAuthProvider = class extends ProxyOAuthServerProvider {
       }
       logger.error({ event: "oauth_token_exchange_failed", status: fetchRes.status, body: text.slice(0, 500) });
       if (fetchRes.status >= 500) {
+        failedAuth("upstream_5xx");
         throw new McpServerError(`Upstream token endpoint error: ${fetchRes.status} ${text.slice(0, 200)}`);
       }
+      failedAuth("business");
       throw new InvalidGrantError(`Plaud token exchange: ${fetchRes.status} ${text.slice(0, 200)}`);
     }
     let data;
     try {
       data = await fetchRes.json();
     } catch (err) {
+      failedAuth("internal");
       logger.error({ event: "oauth_token_json_parse_failed", error: String(err) });
       throw new McpServerError("Token endpoint returned non-JSON response");
     }
     logger.info({ event: "oauth_token_exchange_ok", has_refresh_token: !!data.refresh_token });
+    const authorizedUserId = await this.resolveRealUserId(data.access_token);
+    this._tracker?.track({
+      name: "auth.oauth_callback_success",
+      actorType: "user",
+      userId: authorizedUserId,
+      distinctId: authorizedUserId ?? client.client_id,
+      params: {
+        dcr_client_id: client.client_id,
+        ...normalizeMcpHost(client.client_name) ? { mcp_host: normalizeMcpHost(client.client_name) } : {}
+      }
+    });
     return {
       access_token: data.access_token,
       token_type: data.token_type ?? "Bearer",
@@ -663,7 +731,15 @@ var PlaudOAuthProvider = class extends ProxyOAuthServerProvider {
   // Override refresh too: the SDK proxy implementation would forward the local
   // DCR client_id and RFC 8707 resource to Plaud, but Plaud uses its dedicated
   // refresh endpoint and does not support resource indicators.
-  async exchangeRefreshToken(_client, refreshToken, scopes, resource) {
+  async exchangeRefreshToken(client, refreshToken, scopes, resource) {
+    const failedRefresh = (failureKind) => {
+      this._tracker?.track({
+        name: "auth.token_refresh_error",
+        actorType: "user",
+        distinctId: client.client_id,
+        params: { failure_kind: failureKind }
+      });
+    };
     logger.info({
       event: "oauth_token_refresh_attempt",
       token_url: this._plaudRefreshUrl,
@@ -689,9 +765,11 @@ var PlaudOAuthProvider = class extends ProxyOAuthServerProvider {
       logger.error({ event: "oauth_token_refresh_failed", status: fetchRes.status, body: text.slice(0, 500) });
       if (fetchRes.status >= 500) {
         oauthTokenRefresh.inc({ result: "upstream_error" });
+        failedRefresh("upstream_5xx");
         throw new McpServerError(`Upstream refresh endpoint error: ${fetchRes.status} ${text.slice(0, 200)}`);
       }
       oauthTokenRefresh.inc({ result: "invalid_grant" });
+      failedRefresh("business");
       throw new InvalidGrantError(`Plaud token refresh: ${fetchRes.status} ${text.slice(0, 200)}`);
     }
     let data;
@@ -699,10 +777,18 @@ var PlaudOAuthProvider = class extends ProxyOAuthServerProvider {
       data = await fetchRes.json();
     } catch (err) {
       oauthTokenRefresh.inc({ result: "parse_failed" });
+      failedRefresh("internal");
       logger.error({ event: "oauth_refresh_json_parse_failed", error: String(err) });
       throw new McpServerError("Refresh endpoint returned non-JSON response");
     }
     oauthTokenRefresh.inc({ result: "success" });
+    const refreshedUserId = await this.resolveRealUserId(data.access_token);
+    this._tracker?.track({
+      name: "auth.token_refresh_success",
+      actorType: "user",
+      userId: refreshedUserId,
+      distinctId: refreshedUserId ?? client.client_id
+    });
     logger.info({
       event: "oauth_token_refresh_ok",
       has_refresh_token: !!data.refresh_token,
@@ -718,7 +804,360 @@ var PlaudOAuthProvider = class extends ProxyOAuthServerProvider {
   }
 };
 
+// src/telemetry-server/tracker.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/telemetry-server/transport.ts
+import { PostHog } from "posthog-node";
+var DryRunTransport = class {
+  name = "dry-run";
+  async send(batch) {
+    for (const ev of batch) {
+      logger.info({
+        event: "warehouse_dryrun",
+        emitted_event: ev.event,
+        distinct_id: ev.distinct_id,
+        payload: ev
+      });
+    }
+  }
+};
+var PostHogTransport = class {
+  name = "posthog-node";
+  client;
+  constructor(endpoint, apiKey) {
+    this.client = new PostHog(apiKey, {
+      host: endpoint,
+      flushAt: 5,
+      flushInterval: 1e3,
+      // Self-verification hook: posthog-node's capture() is silent on success,
+      // so we wrap its fetch to log the warehouse's HTTP response code on every
+      // ingestion request. A 2xx here is the warehouse's own ACK that the batch
+      // was received + accepted (auth ok, payload valid) — the only local proof,
+      // short of reading the warehouse, that events actually reach it. Low volume
+      // (one line per flush). Does NOT alter posthog-node's wire path.
+      fetch: async (url, options) => {
+        try {
+          const res = await fetch(url, options);
+          logger.info({
+            event: "warehouse_http_response",
+            status: res.status,
+            ok: res.ok,
+            url
+          });
+          return res;
+        } catch (err) {
+          logger.warn({ event: "warehouse_http_error", url, error: String(err) });
+          throw err;
+        }
+      }
+    });
+  }
+  async send(batch) {
+    for (const ev of batch) {
+      this.client.capture({
+        distinctId: ev.distinct_id,
+        event: ev.event,
+        properties: ev.properties,
+        timestamp: new Date(ev.timestamp),
+        disableGeoip: true
+        // server-side; don't derive geo from the server IP
+      });
+    }
+  }
+  async shutdown() {
+    await this.client.shutdown();
+  }
+};
+
+// src/telemetry-server/tracker.ts
+var EVENT_NAME_RE = /^[a-z]+\.[a-z][a-z0-9_]{2,58}$/;
+var PARAM_KEY_RE = /^[a-z][a-z0-9_]*$/;
+var MAX_BATCH_BYTES = 15 * 1024;
+var WarehouseTracker = class {
+  common;
+  transport;
+  batchSize;
+  flushIntervalMs;
+  queue = [];
+  timer = null;
+  closed = false;
+  constructor(opts) {
+    this.common = opts.common;
+    this.transport = opts.transport ?? new DryRunTransport();
+    this.batchSize = opts.batchSize ?? 5;
+    this.flushIntervalMs = opts.flushIntervalMs ?? 1e3;
+  }
+  /**
+   * Fire-and-forget. Assembles + enqueues one event. Never throws — any error
+   * is logged and swallowed so the HTTP request path is never affected.
+   */
+  track(input) {
+    if (this.closed) return;
+    try {
+      const event = this.assemble(input);
+      this.queue.push(event);
+      if (this.queue.length >= this.batchSize) {
+        void this.flush();
+      } else {
+        this.ensureTimer();
+      }
+    } catch (err) {
+      logger.warn({ event: "warehouse_track_dropped", name: input.name, error: String(err) });
+    }
+  }
+  /** Send everything currently queued. Safe to call anytime. */
+  async flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.queue.length === 0) return;
+    const pending = this.queue;
+    this.queue = [];
+    for (const batch of this.splitBySize(pending)) {
+      try {
+        await this.transport.send(batch);
+      } catch (err) {
+        logger.warn({ event: "warehouse_flush_failed", count: batch.length, error: String(err) });
+      }
+    }
+  }
+  /** Flush remaining events and stop. Call before process exit. */
+  async shutdown() {
+    this.closed = true;
+    await this.flush();
+    try {
+      await this.transport.shutdown?.();
+    } catch (err) {
+      logger.warn({ event: "warehouse_transport_shutdown_failed", error: String(err) });
+    }
+  }
+  // ── internals ──────────────────────────────────────────────────────────
+  ensureTimer() {
+    if (this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.flush();
+    }, this.flushIntervalMs);
+    this.timer.unref?.();
+  }
+  /** Build the full SOP envelope for one event. Throws on invalid input. */
+  assemble(input) {
+    if (!EVENT_NAME_RE.test(input.name)) {
+      throw new Error(`invalid event name (need domain.event_phrase): ${input.name}`);
+    }
+    const distinctId = this.resolveDistinctId(input);
+    if (!distinctId) {
+      throw new Error(`empty distinct_id for ${input.name}`);
+    }
+    const ws = input.workspace ?? {};
+    const properties = {
+      // identity
+      actor_type: input.actorType,
+      ...input.userId ? { user_id: input.userId } : {},
+      ...ws.id ?? this.common.workspaceId ? { workspace_id: ws.id ?? this.common.workspaceId } : {},
+      ...ws.type ?? this.common.workspaceType ? { workspace_type: ws.type ?? this.common.workspaceType } : {},
+      ...ws.memberId ?? this.common.memberId ? { member_id: ws.memberId ?? this.common.memberId } : {},
+      // service / platform / env
+      region: this.common.region,
+      platform: "server",
+      env: this.common.env,
+      service_name: this.common.serviceName,
+      service_version: this.common.serviceVersion,
+      ...this.common.buildId ? { build_id: this.common.buildId } : {},
+      // timing / tracing
+      event_id: randomUUID2(),
+      ...input.requestId ? { request_id: input.requestId } : {},
+      // (trace_id/span_id omitted — no OpenTelemetry; spec forbids fabricating)
+      // non-user actors: don't create a PostHog person
+      ...input.actorType !== "user" ? { $process_person_profile: false } : {},
+      // event-specific custom params
+      ...this.validatedParams(input.params)
+    };
+    return {
+      event: input.name,
+      distinct_id: distinctId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      properties
+    };
+  }
+  /** §3.1 distinct_id rules. */
+  resolveDistinctId(input) {
+    if (input.distinctId) return input.distinctId;
+    if (input.actorType === "user") {
+      if (!input.userId) throw new Error(`actor_type=user requires userId: ${input.name}`);
+      return input.userId;
+    }
+    return this.common.serviceName;
+  }
+  /** Runtime field-name lint only (§4.2): snake_case, no `$`, no nested objects. */
+  validatedParams(params) {
+    if (!params) return {};
+    const out = {};
+    for (const [key, value] of Object.entries(params)) {
+      if (!PARAM_KEY_RE.test(key)) throw new Error(`invalid param key (snake_case, no $): ${key}`);
+      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        throw new Error(`nested object not allowed in param: ${key}`);
+      }
+      out[key] = value;
+    }
+    return out;
+  }
+  /**
+   * Split a list of events into batches each < MAX_BATCH_BYTES. Normally the
+   * batchSize cap (5) keeps us well under 16 KiB; this is the hard safety net.
+   * A single event that alone exceeds the limit is sent on its own with a warn.
+   */
+  splitBySize(events) {
+    const batches = [];
+    let current = [];
+    for (const ev of events) {
+      const evBytes = Buffer.byteLength(JSON.stringify(ev), "utf8");
+      if (evBytes >= MAX_BATCH_BYTES) {
+        if (current.length) {
+          batches.push(current);
+          current = [];
+        }
+        logger.warn({ event: "warehouse_event_oversized", emitted_event: ev.event, bytes: evBytes });
+        batches.push([ev]);
+        continue;
+      }
+      const tentative = [...current, ev];
+      const bytes = Buffer.byteLength(JSON.stringify(tentative), "utf8");
+      if (bytes >= MAX_BATCH_BYTES) {
+        batches.push(current);
+        current = [ev];
+      } else {
+        current = tentative;
+      }
+    }
+    if (current.length) batches.push(current);
+    return batches;
+  }
+};
+
+// src/telemetry-server/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var storage = new AsyncLocalStorage();
+function runWithTelemetryContext(ctx, fn) {
+  return storage.run(ctx, fn);
+}
+function getTelemetryContext() {
+  return storage.getStore() ?? {};
+}
+
+// src/telemetry-server/hooks.ts
+function createWarehouseToolHooks(tracker) {
+  const baseInput = (tool, fileId) => {
+    const ctx = getTelemetryContext();
+    return {
+      actorType: "user",
+      userId: ctx.userId,
+      requestId: ctx.requestId,
+      workspace: ctx.workspace,
+      params: {
+        tool_name: tool,
+        transport: "http",
+        ...fileId ? { file_id: fileId } : {},
+        ...ctx.mcpHost ? { mcp_host: ctx.mcpHost } : {}
+      }
+    };
+  };
+  return {
+    onToolClick({ tool, fileId }) {
+      tracker.track({ name: "mcp.tool_click", ...baseInput(tool, fileId) });
+    },
+    onToolResult({ tool, status, durationMs, fileId, failureKind }) {
+      const base = baseInput(tool, fileId);
+      base.params.duration_ms = durationMs;
+      if (status === "error" && failureKind) base.params.failure_kind = failureKind;
+      tracker.track({
+        name: status === "success" ? "mcp.tool_success" : "mcp.tool_error",
+        ...base
+      });
+    }
+  };
+}
+
+// src/telemetry-server/connectivity.ts
+import dns from "dns/promises";
+import net from "net";
+var TIMEOUT_MS = 8e3;
+var DEFAULT_HOSTS = [
+  "plaud-data-warehouse-staging-usw2-lan.plaud.ai",
+  // staging (David's "test env")
+  "plaud-data-warehouse-usw2-lan.plaud.ai"
+  // production US
+];
+function tcpConnect(host) {
+  return new Promise((resolve) => {
+    const socket = net.connect({ host, port: 443 });
+    const done = (r) => {
+      socket.destroy();
+      resolve(r);
+    };
+    socket.setTimeout(TIMEOUT_MS);
+    socket.once("connect", () => done({ ok: true }));
+    socket.once("timeout", () => done({ ok: false, code: "ETIMEDOUT" }));
+    socket.once("error", (err) => done({ ok: false, code: err.code ?? "ERR" }));
+  });
+}
+async function probeHost(host) {
+  let ips = null;
+  try {
+    ips = (await dns.lookup(host, { all: true })).map((x) => x.address);
+  } catch (err) {
+    logger.info({
+      event: "warehouse_connectivity",
+      host,
+      reachable: false,
+      stage: "dns",
+      code: err.code,
+      verdict: "DNS failed \u2192 internal DNS not resolvable here \u2192 ops: configure DNS"
+    });
+    return;
+  }
+  const tcp = await tcpConnect(host);
+  logger.info({
+    event: "warehouse_connectivity",
+    host,
+    reachable: tcp.ok,
+    stage: tcp.ok ? "tcp_ok" : "tcp",
+    dns_ips: ips,
+    code: tcp.code,
+    verdict: tcp.ok ? "TCP :443 connected \u2192 network path open \u2192 remaining is key/app layer (David)" : `TCP failed (${tcp.code}) \u2192 route/firewall blocked \u2192 ops: allow egress to *.lan:443`
+  });
+}
+function runWarehouseConnectivityCheck(configuredEndpoint) {
+  const hosts = new Set(DEFAULT_HOSTS);
+  if (configuredEndpoint) {
+    try {
+      hosts.add(new URL(configuredEndpoint).hostname);
+    } catch {
+    }
+  }
+  void (async () => {
+    logger.info({ event: "warehouse_connectivity_start", hosts: [...hosts] });
+    for (const h of hosts) {
+      try {
+        await probeHost(h);
+      } catch (err) {
+        logger.warn({ event: "warehouse_connectivity_error", host: h, error: String(err) });
+      }
+    }
+  })();
+}
+
 // src/http/server.ts
+function clientNameFromBody(body) {
+  const msgs = Array.isArray(body) ? body : [body];
+  for (const m of msgs) {
+    const name = m?.params?.clientInfo?.name;
+    if (typeof name === "string" && name) return name;
+  }
+  return void 0;
+}
 var HTTP_PORT = Number(process.env.PLAUD_HTTP_PORT ?? 3e3);
 var HTTP_HOST = process.env.PLAUD_HTTP_HOST ?? "0.0.0.0";
 var CALLBACK_PORT = 8199;
@@ -786,6 +1225,28 @@ function startHttpServer() {
       allow_private_ip: CIMD_ALLOW_PRIVATE_IP
     });
   }
+  const warehouseEndpoint = process.env.PLAUD_WAREHOUSE_ENDPOINT;
+  const warehouseApiKey = process.env.PLAUD_WAREHOUSE_API_KEY;
+  const warehouse = new WarehouseTracker({
+    common: {
+      serviceName: process.env.PLAUD_WAREHOUSE_SERVICE_NAME ?? "plaudmcp",
+      // matches §1.3 key label `plaudmcp:TRACKING_KEY_PLAUDMCP`; confirm exact string with David
+      serviceVersion: "0.3.4",
+      buildId: "ce4457b",
+      // mcp tsup TODO: inject git short SHA (like CLI)
+      region: process.env.PLAUD_REGION ?? "US",
+      env: process.env.PLAUD_ENV ?? process.env.NODE_ENV ?? "development"
+    },
+    transport: warehouseEndpoint && warehouseApiKey ? new PostHogTransport(warehouseEndpoint, warehouseApiKey) : new DryRunTransport()
+  });
+  const warehouseToolHooks = createWarehouseToolHooks(warehouse);
+  logger.info({ event: "warehouse_emitter_ready", transport: warehouseEndpoint && warehouseApiKey ? "posthog-node" : "dry-run" });
+  runWarehouseConnectivityCheck(warehouseEndpoint);
+  const shutdownWarehouse = () => {
+    void warehouse.shutdown();
+  };
+  process.once("SIGTERM", shutdownWarehouse);
+  process.once("SIGINT", shutdownWarehouse);
   const provider = new PlaudOAuthProvider({
     clientId,
     clientSecret,
@@ -795,7 +1256,9 @@ function startHttpServer() {
     refreshUrl: process.env.PLAUD_REFRESH_URL,
     apiBase,
     debugOAuthLogs: OAUTH_DEBUG_LOGS,
-    cimdLoader
+    cimdLoader,
+    tracker: warehouse
+    // auth.* events
   });
   const issuerUrl = new URL(serverUrl);
   const trimmedServerUrl = serverUrl.replace(/\/$/, "");
@@ -875,7 +1338,7 @@ function startHttpServer() {
     });
   }
   app.use((req, res, next) => {
-    const reqId = req.headers["x-request-id"] ?? randomUUID2();
+    const reqId = req.headers["x-request-id"] ?? randomUUID3();
     const startMs = Date.now();
     res.locals["reqId"] = reqId;
     res.on("finish", () => {
@@ -999,7 +1462,7 @@ function startHttpServer() {
     requireBearerAuth({ verifier: provider, resourceMetadataUrl: protectedResourceMetadataUrl }),
     async (req, res) => {
       const token = req.auth.token;
-      const reqId = res.locals["reqId"] ?? randomUUID2();
+      const reqId = res.locals["reqId"] ?? randomUUID3();
       const reqLog = logger.child({ req_id: reqId });
       const startMs = Date.now();
       reqLog.info({ event: "mcp_request_start", client_id: req.auth.clientId });
@@ -1010,30 +1473,38 @@ function startHttpServer() {
         apiBase,
         staticToken: token
       });
-      const mcpServer = new McpServer({ name: "plaud", version: "0.3.2" });
-      registerTools(mcpServer, client);
+      const mcpServer = new McpServer({ name: "plaud", version: "0.3.4" });
+      registerTools(mcpServer, client, warehouseToolHooks);
       const transport = new StreamableHTTPServerTransport({
         sessionIdGenerator: void 0,
         // stateless
         enableDnsRebindingProtection: true,
         allowedOrigins: ALLOWED_ORIGINS
       });
-      try {
-        await mcpServer.connect(transport);
-        await transport.handleRequest(req, res, req.body);
-        const clientVersion = mcpServer.server.getClientVersion();
-        if (clientVersion) {
-          reqLog.info({ event: "mcp_client_info", client_name: clientVersion.name, client_version: clientVersion.version });
-        }
-        reqLog.info({ event: "mcp_request_end", duration_ms: Date.now() - startMs });
-      } catch (err) {
-        reqLog.error({ event: "mcp_request_error", error: String(err), duration_ms: Date.now() - startMs });
-        if (!res.headersSent) {
-          res.status(500).json({ error: String(err) });
+      const ctxUserId = req.auth.clientId && req.auth.clientId !== "unknown" ? req.auth.clientId : void 0;
+      const telemetryCtx = {
+        userId: ctxUserId,
+        requestId: reqId,
+        mcpHost: normalizeMcpHost(clientNameFromBody(req.body))
+      };
+      await runWithTelemetryContext(telemetryCtx, async () => {
+        try {
+          await mcpServer.connect(transport);
+          await transport.handleRequest(req, res, req.body);
+          const clientVersion = mcpServer.server.getClientVersion();
+          if (clientVersion) {
+            reqLog.info({ event: "mcp_client_info", client_name: clientVersion.name, client_version: clientVersion.version });
+          }
+          reqLog.info({ event: "mcp_request_end", duration_ms: Date.now() - startMs });
+        } catch (err) {
+          reqLog.error({ event: "mcp_request_error", error: String(err), duration_ms: Date.now() - startMs });
+          if (!res.headersSent) {
+            res.status(500).json({ error: String(err) });
+          }
+        } finally {
+          await mcpServer.close();
         }
-      } finally {
-        await mcpServer.close();
-      }
+      });
     }
   );
   if (!process.env.PLAUD_CALLBACK_URL) {