@metrone-io/mcp 1.0.0 → 1.0.2

package/README.md

@@ -0,0 +1,57 @@
+# @metrone-io/mcp
+
+[Model Context Protocol](https://modelcontextprotocol.io) server for [Metrone](https://metrone.io) analytics. Gives AI agents (Claude, GPT, Cursor, etc.) native access to your analytics data.
+
+## Install
+
+```bash
+npm install -g @metrone-io/mcp
+```
+
+## Setup
+
+Add to your MCP client configuration:
+
+```json
+{
+  "mcpServers": {
+    "metrone": {
+      "command": "npx",
+      "args": ["-y", "@metrone-io/mcp"],
+      "env": {
+        "METRONE_API_KEY": "metrone_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      }
+    }
+  }
+}
+```
+
+Optionally set `METRONE_ENDPOINT` to override the default API base URL (`https://api.metrone.io`).
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `metrone_get_stats` | Aggregate analytics (pageviews, visitors, bounce rate) |
+| `metrone_get_events` | Recent events with filtering |
+| `metrone_get_pages` | Top pages by views |
+| `metrone_get_sources` | Traffic sources breakdown |
+| `metrone_get_live` | Current live visitors |
+| `metrone_track_event` | Track a custom event |
+| `metrone_track_ai_call` | Track an AI call or chat session |
+
+## Example
+
+Ask your AI agent:
+
+> "How many pageviews did we get this week?"
+> "What are our top traffic sources?"
+> "Track a conversion event for user signup"
+
+## Documentation
+
+[metrone.io/docs](https://metrone.io/docs)
+
+## License
+
+[MIT](../../LICENSE)

package/dist/index.js

@@ -1,153 +1,257 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-var API_KEY = process.env.METRONE_API_KEY;
-var ENDPOINT = process.env.METRONE_ENDPOINT ?? "https://api.metrone.io";
-if (!API_KEY) {
-  console.error("METRONE_API_KEY environment variable is required");
-  process.exit(1);
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools.ts
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? String(v) : void 0;
 }
-async function apiGet(path, params) {
-  const url = new URL(path, ENDPOINT);
-  if (params) {
-    for (const [k, v] of Object.entries(params)) {
-      if (v !== void 0 && v !== "") url.searchParams.set(k, v);
-    }
-  }
-  const res = await fetch(url.toString(), {
-    headers: { "X-Api-Key": API_KEY }
-  });
-  if (!res.ok) {
-    const body = await res.text();
-    throw new Error(`Metrone API error ${res.status}: ${body}`);
-  }
-  return res.json();
+function str(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
 }
-async function apiPost(path, body) {
-  const url = new URL(path, ENDPOINT);
-  const res = await fetch(url.toString(), {
-    method: "POST",
-    headers: { "X-Api-Key": API_KEY, "Content-Type": "application/json" },
-    body: JSON.stringify(body)
-  });
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Metrone API error ${res.status}: ${text}`);
+function query(entries) {
+  const out = {};
+  for (const [k, v] of Object.entries(entries)) {
+    if (v !== void 0) out[k] = v;
   }
-  return res.json();
-}
-function textResult(data) {
-  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+  return out;
 }
-var server = new McpServer({ name: "metrone", version: "1.0.0" });
-server.tool(
-  "metrone_get_stats",
+var TOOLS = [
   {
-    days: z.number().optional(),
-    from: z.string().optional(),
-    to: z.string().optional()
+    name: "metrone_get_stats",
+    description: "Get aggregated analytics statistics (events, pageviews, visitors, sessions, conversion rate) for a time period.",
+    scope: "read",
+    inputSchema: {
+      type: "object",
+      properties: {
+        days: { type: "number", description: "Look-back window in days (default 30)" },
+        from: { type: "string", description: "ISO 8601 start date (overrides days)" },
+        to: { type: "string", description: "ISO 8601 end date" }
+      }
+    },
+    buildRequest: (args) => ({
+      method: "GET",
+      path: "/v1/api/stats",
+      query: query({ days: num(args.days), from: str(args.from), to: str(args.to) })
+    })
   },
-  async ({ days, from, to }) => {
-    const params = {};
-    if (days !== void 0) params.days = String(days);
-    if (from) params.from = from;
-    if (to) params.to = to;
-    return textResult(await apiGet("/v1/api/stats", params));
-  }
-);
-server.tool(
-  "metrone_get_events",
   {
-    days: z.number().optional(),
-    limit: z.number().optional(),
-    event_type: z.string().optional(),
-    source: z.string().optional()
+    name: "metrone_get_events",
+    description: "Query raw analytics events with optional filters for event type and source.",
+    scope: "read",
+    inputSchema: {
+      type: "object",
+      properties: {
+        days: { type: "number" },
+        limit: { type: "number" },
+        event_type: { type: "string" },
+        source: { type: "string" }
+      }
+    },
+    buildRequest: (args) => ({
+      method: "GET",
+      path: "/v1/api/events",
+      query: query({
+        days: num(args.days),
+        limit: num(args.limit),
+        event_type: str(args.event_type),
+        source: str(args.source)
+      })
+    })
   },
-  async ({ days, limit, event_type, source }) => {
-    const params = {};
-    if (days !== void 0) params.days = String(days);
-    if (limit !== void 0) params.limit = String(limit);
-    if (event_type) params.event_type = event_type;
-    if (source) params.source = source;
-    return textResult(await apiGet("/v1/api/events", params));
-  }
-);
-server.tool(
-  "metrone_get_pages",
   {
-    days: z.number().optional(),
-    limit: z.number().optional()
+    name: "metrone_get_pages",
+    description: "Get top pages by views and sessions.",
+    scope: "read",
+    inputSchema: {
+      type: "object",
+      properties: {
+        days: { type: "number" },
+        limit: { type: "number" }
+      }
+    },
+    buildRequest: (args) => ({
+      method: "GET",
+      path: "/v1/api/pages",
+      query: query({ days: num(args.days), limit: num(args.limit) })
+    })
   },
-  async ({ days, limit }) => {
-    const params = {};
-    if (days !== void 0) params.days = String(days);
-    if (limit !== void 0) params.limit = String(limit);
-    return textResult(await apiGet("/v1/api/pages", params));
-  }
-);
-server.tool(
-  "metrone_get_sources",
-  { days: z.number().optional() },
-  async ({ days }) => {
-    const params = {};
-    if (days !== void 0) params.days = String(days);
-    return textResult(await apiGet("/v1/api/sources", params));
-  }
-);
-server.tool(
-  "metrone_get_live",
-  {},
-  async (_args) => textResult(await apiGet("/v1/api/live"))
-);
-server.tool(
-  "metrone_track_event",
   {
-    event_type: z.string(),
-    source: z.string().optional(),
-    event_name: z.string().optional(),
-    page_url: z.string().optional(),
-    properties: z.record(z.string(), z.any()).optional()
+    name: "metrone_get_sources",
+    description: "Get traffic source and referrer breakdown.",
+    scope: "read",
+    inputSchema: {
+      type: "object",
+      properties: {
+        days: { type: "number" }
+      }
+    },
+    buildRequest: (args) => ({
+      method: "GET",
+      path: "/v1/api/sources",
+      query: query({ days: num(args.days) })
+    })
   },
-  async ({ event_type, source, event_name, page_url, properties }) => {
-    const payload = {
-      api_key: API_KEY,
-      event_type,
-      source: source ?? "assistant"
-    };
-    if (event_name) payload.event_name = event_name;
-    if (page_url) payload.page_url = page_url;
-    if (properties) payload.properties = properties;
-    return textResult(await apiPost("/v1/api/events", payload));
-  }
-);
-server.tool(
-  "metrone_track_ai_call",
   {
-    call_id: z.string(),
-    provider: z.string(),
-    duration: z.number().optional(),
-    intent: z.string().optional(),
-    outcome: z.string().optional(),
-    properties: z.record(z.string(), z.any()).optional()
+    name: "metrone_get_live",
+    description: "Get real-time stats: active visitors and today\u2019s totals.",
+    scope: "read",
+    inputSchema: { type: "object", properties: {} },
+    buildRequest: () => ({ method: "GET", path: "/v1/api/live", query: {} })
   },
-  async ({ call_id, provider, duration, intent, outcome, properties }) => {
-    const payload = {
-      api_key: API_KEY,
-      event_type: "ai_call",
-      source: "voice",
-      ai_call_id: call_id,
-      ai_provider: provider
-    };
-    if (duration !== void 0) payload.ai_duration_sec = duration;
-    if (intent) payload.ai_intent = intent;
-    if (properties || outcome) {
-      payload.properties = { ...properties, ...outcome && { outcome } };
+  {
+    name: "metrone_track_event",
+    description: "Track a custom analytics event.",
+    scope: "write",
+    inputSchema: {
+      type: "object",
+      properties: {
+        event_type: { type: "string" },
+        source: { type: "string", description: 'Event source (defaults to "assistant")' },
+        event_name: { type: "string" },
+        page_url: { type: "string" },
+        properties: { type: "object" }
+      },
+      required: ["event_type"]
+    },
+    buildRequest: (args) => {
+      const body = {
+        event_type: args.event_type,
+        source: str(args.source) ?? "assistant"
+      };
+      if (str(args.event_name)) body.event_name = args.event_name;
+      if (str(args.page_url)) body.page_url = args.page_url;
+      if (args.properties && typeof args.properties === "object") body.properties = args.properties;
+      return { method: "POST", path: "/v1/api/events", body };
     }
-    return textResult(await apiPost("/v1/api/events", payload));
+  },
+  {
+    name: "metrone_track_ai_call",
+    description: "Track an AI call event (voice / chat / assistant interaction).",
+    scope: "write",
+    inputSchema: {
+      type: "object",
+      properties: {
+        call_id: { type: "string" },
+        provider: { type: "string" },
+        source: { type: "string", enum: ["voice", "chat", "assistant"] },
+        duration: { type: "number", description: "Duration in seconds" },
+        intent: { type: "string" },
+        outcome: { type: "string" },
+        properties: { type: "object" }
+      },
+      required: ["call_id", "provider"]
+    },
+    buildRequest: (args) => {
+      const body = {
+        event_type: "ai_call",
+        source: str(args.source) ?? "voice",
+        ai_call_id: args.call_id,
+        ai_provider: args.provider
+      };
+      if (typeof args.duration === "number") body.ai_duration_sec = args.duration;
+      if (str(args.intent)) body.ai_intent = args.intent;
+      const props = args.properties && typeof args.properties === "object" ? args.properties : void 0;
+      if (props || str(args.outcome)) {
+        body.properties = { ...props, ...str(args.outcome) ? { outcome: args.outcome } : {} };
+      }
+      return { method: "POST", path: "/v1/api/events", body };
+    }
+  }
+];
+var TOOLS_BY_NAME = new Map(TOOLS.map((t) => [t.name, t]));
+function listTools() {
+  return TOOLS.map(({ name, description, inputSchema }) => ({ name, description, inputSchema }));
+}
+function getTool(name) {
+  return TOOLS_BY_NAME.get(name);
+}
+var ToolValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ToolValidationError";
+  }
+};
+function validateArgs(tool, args) {
+  const required = tool.inputSchema.required ?? [];
+  for (const field of required) {
+    const v = args[field];
+    if (v === void 0 || v === null || typeof v === "string" && v.length === 0) {
+      throw new ToolValidationError(`Missing required argument: ${field}`);
+    }
+  }
+}
+async function dispatch(toolName, args, executor) {
+  const tool = getTool(toolName);
+  if (!tool) {
+    throw new ToolValidationError(`Unknown tool: ${toolName}`);
+  }
+  validateArgs(tool, args);
+  return executor(tool.buildRequest(args));
+}
+
+// src/index.ts
+var API_KEY = process.env.METRONE_API_KEY;
+var ENDPOINT = process.env.METRONE_ENDPOINT ?? "https://api.metrone.io";
+if (!API_KEY) {
+  console.error("METRONE_API_KEY environment variable is required");
+  process.exit(1);
+}
+var REQUEST_TIMEOUT_MS = 3e4;
+var httpExecutor = async (req) => {
+  const url = new URL(req.path, ENDPOINT);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    let res;
+    if (req.method === "GET") {
+      for (const [k, v] of Object.entries(req.query)) {
+        if (v !== void 0 && v !== "") url.searchParams.set(k, v);
+      }
+      res = await fetch(url.toString(), {
+        headers: { "X-Api-Key": API_KEY },
+        signal: controller.signal
+      });
+    } else {
+      res = await fetch(url.toString(), {
+        method: "POST",
+        headers: { "X-Api-Key": API_KEY, "Content-Type": "application/json" },
+        body: JSON.stringify({ api_key: API_KEY, ...req.body }),
+        signal: controller.signal
+      });
+    }
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`Metrone API error ${res.status}: ${body}`);
+    }
+    return res.json();
+  } finally {
+    clearTimeout(timer);
   }
+};
+var server = new Server(
+  { name: "metrone", version: "1.0.1" },
+  { capabilities: { tools: {} } }
 );
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: listTools()
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    const data = await dispatch(name, args ?? {}, httpExecutor);
+    return {
+      content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+    };
+  } catch (err) {
+    return {
+      content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
+      isError: true
+    };
+  }
+});
 var transport = new StdioServerTransport();
 await server.connect(transport);

package/dist/tools.d.ts

@@ -0,0 +1,78 @@
+/**
+ * tools.ts — shared MCP tool registry (v1.1 SPEC-06A)
+ *
+ * Single source of truth for Metrone's MCP tools, consumed by BOTH transports:
+ *
+ *   - stdio  (src/index.ts, the published @metrone-io/mcp binary): injects an
+ *     HTTP executor that fetches METRONE_ENDPOINT with the env API key.
+ *   - HTTP   (packages/worker /mcp route): injects an INTERNAL executor that
+ *     synthesizes Requests against the worker's own handlers — no self-fetch
+ *     (Cloudflare blocks same-zone worker self-fetch) and no extra network hop.
+ *
+ * Adding a tool here makes it available on both transports automatically
+ * (this is the contract SPEC-06B relies on when it adds 8 more tools).
+ *
+ * Design constraints:
+ *   - This module is dependency-free (no zod, no MCP SDK) so the worker can
+ *     bundle it without dragging Node-targeted dependencies into the
+ *     Cloudflare runtime. Input schemas are plain JSON Schema — which is
+ *     what the MCP wire protocol (tools/list) wants anyway.
+ *   - Validation here is intentionally light (required fields + basic types).
+ *     The REST API performs the authoritative validation; duplicating it
+ *     would drift.
+ */
+/** A request a tool wants to make against the Metrone REST API. */
+type ToolApiRequest = {
+    method: 'GET';
+    path: string;
+    query: Record<string, string>;
+} | {
+    method: 'POST';
+    path: string;
+    body: Record<string, unknown>;
+};
+/**
+ * Transport-specific executor. Receives the API request spec, performs it
+ * (HTTP fetch for stdio, internal handler dispatch for the worker), and
+ * returns the parsed JSON response body. MUST throw on non-2xx responses —
+ * dispatch() converts throws into MCP isError tool results.
+ */
+type ToolExecutor = (req: ToolApiRequest) => Promise<unknown>;
+type ToolScope = 'read' | 'write';
+interface ToolDescriptor {
+    name: string;
+    description: string;
+    /** Plain JSON Schema (draft-07 subset) for the MCP tools/list response. */
+    inputSchema: Record<string, unknown>;
+    /** Minimum API-key scope this tool needs. */
+    scope: ToolScope;
+    /** Translate validated args into an API request spec. */
+    buildRequest: (args: Record<string, unknown>) => ToolApiRequest;
+}
+declare const TOOLS: ToolDescriptor[];
+/** Tool list in MCP tools/list wire format. */
+declare function listTools(): Array<{
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}>;
+declare function getTool(name: string): ToolDescriptor | undefined;
+declare class ToolValidationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Validate args against the tool's required fields. Light by design — the
+ * REST API is the authoritative validator. Throws ToolValidationError so
+ * transports can map it to the right error shape (-32602 for JSON-RPC,
+ * isError result for tool calls).
+ */
+declare function validateArgs(tool: ToolDescriptor, args: Record<string, unknown>): void;
+/**
+ * Execute a tool by name through the injected executor. Returns the parsed
+ * API response. Throws:
+ *   - ToolValidationError for unknown tool / missing required args
+ *   - whatever the executor throws for API failures
+ */
+declare function dispatch(toolName: string, args: Record<string, unknown>, executor: ToolExecutor): Promise<unknown>;
+
+export { TOOLS, type ToolApiRequest, type ToolDescriptor, type ToolExecutor, type ToolScope, ToolValidationError, dispatch, getTool, listTools, validateArgs };

package/dist/tools.js

@@ -0,0 +1,195 @@
+// src/tools.ts
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? String(v) : void 0;
+}
+function str(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function query(entries) {
+  const out = {};
+  for (const [k, v] of Object.entries(entries)) {
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
+var TOOLS = [
+  {
+    name: "metrone_get_stats",
+    description: "Get aggregated analytics statistics (events, pageviews, visitors, sessions, conversion rate) for a time period.",
+    scope: "read",
+    inputSchema: {
+      type: "object",
+      properties: {
+        days: { type: "number", description: "Look-back window in days (default 30)" },
+        from: { type: "string", description: "ISO 8601 start date (overrides days)" },
+        to: { type: "string", description: "ISO 8601 end date" }
+      }
+    },
+    buildRequest: (args) => ({
+      method: "GET",
+      path: "/v1/api/stats",
+      query: query({ days: num(args.days), from: str(args.from), to: str(args.to) })
+    })
+  },
+  {
+    name: "metrone_get_events",
+    description: "Query raw analytics events with optional filters for event type and source.",
+    scope: "read",
+    inputSchema: {
+      type: "object",
+      properties: {
+        days: { type: "number" },
+        limit: { type: "number" },
+        event_type: { type: "string" },
+        source: { type: "string" }
+      }
+    },
+    buildRequest: (args) => ({
+      method: "GET",
+      path: "/v1/api/events",
+      query: query({
+        days: num(args.days),
+        limit: num(args.limit),
+        event_type: str(args.event_type),
+        source: str(args.source)
+      })
+    })
+  },
+  {
+    name: "metrone_get_pages",
+    description: "Get top pages by views and sessions.",
+    scope: "read",
+    inputSchema: {
+      type: "object",
+      properties: {
+        days: { type: "number" },
+        limit: { type: "number" }
+      }
+    },
+    buildRequest: (args) => ({
+      method: "GET",
+      path: "/v1/api/pages",
+      query: query({ days: num(args.days), limit: num(args.limit) })
+    })
+  },
+  {
+    name: "metrone_get_sources",
+    description: "Get traffic source and referrer breakdown.",
+    scope: "read",
+    inputSchema: {
+      type: "object",
+      properties: {
+        days: { type: "number" }
+      }
+    },
+    buildRequest: (args) => ({
+      method: "GET",
+      path: "/v1/api/sources",
+      query: query({ days: num(args.days) })
+    })
+  },
+  {
+    name: "metrone_get_live",
+    description: "Get real-time stats: active visitors and today\u2019s totals.",
+    scope: "read",
+    inputSchema: { type: "object", properties: {} },
+    buildRequest: () => ({ method: "GET", path: "/v1/api/live", query: {} })
+  },
+  {
+    name: "metrone_track_event",
+    description: "Track a custom analytics event.",
+    scope: "write",
+    inputSchema: {
+      type: "object",
+      properties: {
+        event_type: { type: "string" },
+        source: { type: "string", description: 'Event source (defaults to "assistant")' },
+        event_name: { type: "string" },
+        page_url: { type: "string" },
+        properties: { type: "object" }
+      },
+      required: ["event_type"]
+    },
+    buildRequest: (args) => {
+      const body = {
+        event_type: args.event_type,
+        source: str(args.source) ?? "assistant"
+      };
+      if (str(args.event_name)) body.event_name = args.event_name;
+      if (str(args.page_url)) body.page_url = args.page_url;
+      if (args.properties && typeof args.properties === "object") body.properties = args.properties;
+      return { method: "POST", path: "/v1/api/events", body };
+    }
+  },
+  {
+    name: "metrone_track_ai_call",
+    description: "Track an AI call event (voice / chat / assistant interaction).",
+    scope: "write",
+    inputSchema: {
+      type: "object",
+      properties: {
+        call_id: { type: "string" },
+        provider: { type: "string" },
+        source: { type: "string", enum: ["voice", "chat", "assistant"] },
+        duration: { type: "number", description: "Duration in seconds" },
+        intent: { type: "string" },
+        outcome: { type: "string" },
+        properties: { type: "object" }
+      },
+      required: ["call_id", "provider"]
+    },
+    buildRequest: (args) => {
+      const body = {
+        event_type: "ai_call",
+        source: str(args.source) ?? "voice",
+        ai_call_id: args.call_id,
+        ai_provider: args.provider
+      };
+      if (typeof args.duration === "number") body.ai_duration_sec = args.duration;
+      if (str(args.intent)) body.ai_intent = args.intent;
+      const props = args.properties && typeof args.properties === "object" ? args.properties : void 0;
+      if (props || str(args.outcome)) {
+        body.properties = { ...props, ...str(args.outcome) ? { outcome: args.outcome } : {} };
+      }
+      return { method: "POST", path: "/v1/api/events", body };
+    }
+  }
+];
+var TOOLS_BY_NAME = new Map(TOOLS.map((t) => [t.name, t]));
+function listTools() {
+  return TOOLS.map(({ name, description, inputSchema }) => ({ name, description, inputSchema }));
+}
+function getTool(name) {
+  return TOOLS_BY_NAME.get(name);
+}
+var ToolValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ToolValidationError";
+  }
+};
+function validateArgs(tool, args) {
+  const required = tool.inputSchema.required ?? [];
+  for (const field of required) {
+    const v = args[field];
+    if (v === void 0 || v === null || typeof v === "string" && v.length === 0) {
+      throw new ToolValidationError(`Missing required argument: ${field}`);
+    }
+  }
+}
+async function dispatch(toolName, args, executor) {
+  const tool = getTool(toolName);
+  if (!tool) {
+    throw new ToolValidationError(`Unknown tool: ${toolName}`);
+  }
+  validateArgs(tool, args);
+  return executor(tool.buildRequest(args));
+}
+export {
+  TOOLS,
+  ToolValidationError,
+  dispatch,
+  getTool,
+  listTools,
+  validateArgs
+};

package/package.json

@@ -1,9 +1,16 @@
 {
   "name": "@metrone-io/mcp",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Metrone MCP server — expose analytics to AI agents via Model Context Protocol",
   "type": "module",
   "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./tools": {
+      "types": "./dist/tools.d.ts",
+      "default": "./dist/tools.js"
+    }
+  },
   "bin": {
     "metrone-mcp": "./dist/index.js"
   },
@@ -12,6 +19,7 @@
     "dev": "tsup --watch",
     "start": "node dist/index.js",
     "clean": "rimraf dist",
+    "prepare": "npm run build",
     "prepublishOnly": "npm run clean && npm run build"
   },
   "publishConfig": {
@@ -21,9 +29,27 @@
     "dist",
     "README.md"
   ],
+  "keywords": [
+    "metrone",
+    "mcp",
+    "model-context-protocol",
+    "analytics",
+    "ai-agents"
+  ],
+  "author": "Metrone",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/metrone-io/sdks.git",
+    "directory": "packages/mcp"
+  },
+  "bugs": {
+    "url": "https://github.com/metrone-io/sdks/issues"
+  },
+  "homepage": "https://metrone.io",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "zod": "^4.3.6"
+    "zod": "^3.23.0"
   },
   "devDependencies": {
     "tsup": "^8.0.0",