hevy-mcp 1.25.17 → 1.26.0

package/README.md

@@ -205,6 +205,15 @@ Docker-based workflows are retired. The provided `Dockerfile` now exits with a m
 
 For a detailed senior engineer guide, please refer to [AGENTS.md](./AGENTS.md).
 
+### Pull Request Checks
+
+- **Conventional Commits**: CI lints commit messages on pull requests, so use
+  prefixes such as `feat:`, `fix:`, `docs:`, `ci:`, `chore:`, `refactor:`,
+  `test:`, or `style:`.
+- **Changesets**: Contributor pull requests targeting `main` must include a
+  changeset. Dependabot PRs and automated `changeset-release/main` release PRs
+  are handled by automation and skip this check.
+
 ### API Client Generation
 
 The API client is automatically generated from the OpenAPI spec using [Kubb](https://kubb.dev/):
@@ -215,24 +224,40 @@ npm run build:client
 
 ### Versioning & Releases
 
-This project uses [Changesets](https://github.com/changesets/changesets) to manage versioning, changelogs, releases, and pull request validation.
-
-1. **Every Pull Request Needs a Changeset**: If your change should ship in the next release, run:
+This project uses [Changesets](https://github.com/changesets/changesets) to
+manage versioning, changelogs, releases, and pull request validation.
+
+1. **Routine Release Cadence**: Merge the automated
+   `changeset-release/main` (**"Version Packages"**) Pull Request on a regular
+   cadence (weekly is a good default) instead of ad-hoc frequent merges.
+2. **Urgent Release Exception**: Security fixes and high-impact,
+   user-facing bug fixes can be released immediately outside the routine
+   cadence.
+3. **Use Bump Changesets Only for User-Facing Runtime Changes**: If your
+   change is user-facing/runtime-visible, run:
    ```bash
    npx changeset
    ```
-   Follow the prompts to specify the type of change (patch, minor, major) and write a short summary of your change. This creates a markdown file under the `.changeset/` directory.
-2. **Use an Empty Changeset for Non-Release Changes**: Docs, CI, test-only, refactor, and chore changes should still include an empty changeset:
+   Follow the prompts to choose `patch`, `minor`, or `major`, then write a
+   short summary. This creates a markdown file under `.changeset/`.
+4. **Use Empty Changesets for Internal-Only Work**: Docs, CI, test-only,
+   refactor, and chore changes should use an empty changeset:
    ```bash
    npx changeset --empty
    ```
-3. **Validate Before Opening a PR**: Pull requests targeting `main` are checked for a changeset in CI. You can run the same validation locally with:
+5. **Validate Before Opening a PR**: Contributor pull requests targeting
+   `main` are checked for a changeset in CI. Dependabot PRs and automated
+   `changeset-release/main` release PRs are handled separately. You can run the
+   same validation locally with:
    ```bash
    npm run check:changeset
    ```
-4. **Automated Releases**:
-   - Pushing changesets to `main` triggers a GitHub Action that automatically creates or updates a **"Version Packages"** Pull Request.
-   - When this Pull Request is merged, the package is automatically built, published to npm (via OIDC Trusted Publishing), and a GitHub Release is created.
+6. **Automated Releases**:
+   - Pushing changesets to `main` triggers a GitHub Action that automatically
+     creates or updates a **"Version Packages"** Pull Request.
+   - When this Pull Request is merged, the package is automatically built,
+     published to npm (via OIDC Trusted Publishing), and a GitHub Release is
+     created.
 
 ---
 

package/dist/cli.mjs

@@ -4,12 +4,12 @@
 (function() {
 	try {
 		var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {};
-		e.SENTRY_RELEASE = { id: "hevy-mcp@1.25.17" };
+		e.SENTRY_RELEASE = { id: "hevy-mcp@1.26.0" };
 		var n = new e.Error().stack;
 		n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "03cf150f-6466-4ca3-9cf1-e423cc0e3cd2", e._sentryDebugIdIdentifier = "sentry-dbid-03cf150f-6466-4ca3-9cf1-e423cc0e3cd2");
 	} catch (e) {}
 })();
-import { r as runServer } from "./src-1TMPprRG.mjs";
+import { r as runServer } from "./src-Di7keTQA.mjs";
 //#region src/cli.ts
 runServer().catch((error) => {
 	console.error("Fatal error in main():", error);

package/dist/index.mjs

@@ -4,10 +4,10 @@
 (function() {
 	try {
 		var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {};
-		e.SENTRY_RELEASE = { id: "hevy-mcp@1.25.17" };
+		e.SENTRY_RELEASE = { id: "hevy-mcp@1.26.0" };
 		var n = new e.Error().stack;
 		n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "5b077b94-9ef8-4f24-a0b0-8dcfbf491be1", e._sentryDebugIdIdentifier = "sentry-dbid-5b077b94-9ef8-4f24-a0b0-8dcfbf491be1");
 	} catch (e) {}
 })();
-import { n as createServer, r as runServer, t as configSchema } from "./src-1TMPprRG.mjs";
+import { n as createServer, r as runServer, t as configSchema } from "./src-Di7keTQA.mjs";
 export { configSchema, createServer, createServer as default, runServer };

package/dist/{src-1TMPprRG.mjs → src-Di7keTQA.mjs}

@@ -4,18 +4,125 @@
 (function() {
 	try {
 		var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {};
-		e.SENTRY_RELEASE = { id: "hevy-mcp@1.25.17" };
+		e.SENTRY_RELEASE = { id: "hevy-mcp@1.26.0" };
 		var n = new e.Error().stack;
-		n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "48707722-f5a5-44ae-899d-34d121b07bcf", e._sentryDebugIdIdentifier = "sentry-dbid-48707722-f5a5-44ae-899d-34d121b07bcf");
+		n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "b6fef1cd-aaf1-497b-af9e-7d50fa405061", e._sentryDebugIdIdentifier = "sentry-dbid-b6fef1cd-aaf1-497b-af9e-7d50fa405061");
 	} catch (e) {}
 })();
 import * as Sentry from "@sentry/node";
+import { SentryPropagator, SentrySampler, SentrySpanProcessor } from "@sentry/opentelemetry";
+import { SpanStatusCode, metrics, trace } from "@opentelemetry/api";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
 import { createHmac } from "node:crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import axios, { isAxiosError } from "axios";
 import { deserializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js";
+//#region src/utils/telemetry.ts
+/**
+* Centralized telemetry initialization.
+*
+* This module MUST be imported before any other application code.
+* It sets up OpenTelemetry with dual export: Sentry (error events +
+* traces) and an OTel Collector (traces + metrics to Honeycomb).
+*
+* Sentry SDK: error events, performance traces, release tracking
+* OTel Collector → Honeycomb: performance traces, metrics
+*/
+const name$1 = "hevy-mcp";
+const version$1 = "1.26.0";
+const collectorToken = process.env.OTEL_COLLECTOR_TOKEN ?? "";
+const COLLECTOR_ENDPOINT = "https://otel.chrisdoc.dev/v1";
+const sentryRelease = process.env.SENTRY_RELEASE ?? `hevy-mcp@1.26.0`;
+const resource = resourceFromAttributes({
+	"service.name": name$1,
+	"service.version": version$1
+});
+const rawDsn = process.env.SENTRY_DSN ?? "https://ce696d8333b507acbf5203eb877bce0f@o4508975499575296.ingest.de.sentry.io/4509049671647312";
+const isValidDsn = typeof rawDsn === "string" && rawDsn.length > 0 && !rawDsn.startsWith("*");
+const sentryClient = Sentry.init({
+	dsn: isValidDsn ? rawDsn : void 0,
+	release: sentryRelease,
+	tracesSampleRate: 1,
+	sendDefaultPii: false,
+	skipOpenTelemetrySetup: true,
+	registerEsmLoaderHooks: false,
+	ignoreErrors: ["EPIPE", "broken pipe"]
+});
+const spanProcessors = [new SentrySpanProcessor()];
+if (collectorToken) spanProcessors.push(new BatchSpanProcessor(new OTLPTraceExporter({
+	url: `${COLLECTOR_ENDPOINT}/traces`,
+	headers: { Authorization: `Bearer ${collectorToken}` }
+})));
+const tracerProvider = new NodeTracerProvider({
+	resource,
+	sampler: sentryClient ? new SentrySampler(sentryClient) : void 0,
+	spanProcessors
+});
+tracerProvider.register({
+	propagator: new SentryPropagator(),
+	contextManager: new Sentry.SentryContextManager()
+});
+if (collectorToken) {
+	const meterProvider = new MeterProvider({
+		resource,
+		readers: [new PeriodicExportingMetricReader({
+			exporter: new OTLPMetricExporter({
+				url: `${COLLECTOR_ENDPOINT}/metrics`,
+				headers: { Authorization: `Bearer ${collectorToken}` }
+			}),
+			exportIntervalMillis: 1e4
+		})]
+	});
+	metrics.setGlobalMeterProvider(meterProvider);
+}
+trace.setGlobalTracerProvider(tracerProvider);
+Sentry.validateOpenTelemetrySetup();
+const tracer = trace.getTracer(name$1);
+const meter = metrics.getMeter(name$1);
+let currentUserId;
+function setCurrentUserId(id) {
+	currentUserId = id;
+}
+function getCurrentUserId() {
+	return currentUserId;
+}
+//#endregion
+//#region src/utils/metrics.ts
+/**
+* Metric instruments for Honeycomb.
+*
+* These are created once from the shared meter provider and exported
+* for use throughout the codebase. All instruments are sent to Honeycomb
+* via the OTLP metrics exporter configured in telemetry.ts.
+*/
+/** Total MCP tool invocations, grouped by tool name. */
+const toolInvocations = meter.createCounter("mcp.tool.invocations", { description: "Total MCP tool invocations" });
+/** Total MCP tool errors, grouped by tool name and error type. */
+const toolErrors = meter.createCounter("mcp.tool.errors", { description: "Total MCP tool errors" });
+/** MCP tool execution duration in milliseconds. */
+const toolDuration = meter.createHistogram("mcp.tool.duration_ms", {
+	description: "MCP tool execution duration in milliseconds",
+	unit: "ms"
+});
+/** Total Hevy API calls, grouped by method, endpoint, and status code. */
+const apiCalls = meter.createCounter("hevy.api.calls", { description: "Total Hevy API calls" });
+/** Hevy API response time in milliseconds. */
+const apiDuration = meter.createHistogram("hevy.api.duration_ms", {
+	description: "Hevy API response time in milliseconds",
+	unit: "ms"
+});
+/** Total stdio JSON parse errors, grouped by failure location. */
+const stdioParseErrors = meter.createCounter("mcp.stdio.parse_errors", { description: "Total stdio JSON parse errors" });
+/** Total server startup count, grouped by version. */
+const serverStartups = meter.createCounter("mcp.server.startups", { description: "Total server startup count" });
+//#endregion
 //#region src/utils/error-handler.ts
 /**
 * Centralized error handling utility for MCP tools
@@ -77,23 +184,26 @@ function determineErrorType(error, message) {
 function withErrorHandling(fn, context) {
 	return async (args) => {
 		const argumentKeyCount = Object.keys(args).length;
-		return Sentry.startSpan({
-			name: `mcp.tool.${context}`,
-			op: "mcp.tool.execute",
-			attributes: {
-				"mcp.tool.context": context,
-				"mcp.tool.args.key_count": argumentKeyCount
-			}
-		}, async (span) => {
+		const startTime = Date.now();
+		toolInvocations.add(1, { tool_name: context });
+		return tracer.startActiveSpan(`mcp.tool.${context}`, { attributes: {
+			"mcp.tool.name": context,
+			"mcp.tool.args.key_count": argumentKeyCount,
+			...getCurrentUserId() ? { "user.id": getCurrentUserId() } : {}
+		} }, async (span) => {
 			try {
 				const result = await fn(args);
-				span.setStatus({ code: 1 });
+				span.setStatus({ code: SpanStatusCode.OK });
 				span.setAttribute("mcp.tool.result.is_error", Boolean(result.isError));
 				return result;
 			} catch (error) {
-				span.setStatus({
-					code: 2,
-					message: "tool_handler_error"
+				span.setStatus({ code: SpanStatusCode.ERROR });
+				span.recordException(error);
+				const errorType = determineErrorType(error, error instanceof Error ? error.message : String(error));
+				span.setAttribute("error.type", errorType);
+				toolErrors.add(1, {
+					tool_name: context,
+					error_type: errorType
 				});
 				Sentry.withScope((scope) => {
 					scope.setTag("mcp.tool.context", context);
@@ -104,6 +214,9 @@ function withErrorHandling(fn, context) {
 					Sentry.captureException(error);
 				});
 				return createErrorResponse(error, context);
+			} finally {
+				toolDuration.record(Date.now() - startTime, { tool_name: context });
+				span.end();
 			}
 		});
 	};
@@ -1681,11 +1794,98 @@ async function putV1WorkoutsWorkoutid(workoutId, data, headers, config = {}) {
 function wrapApi(fn) {
 	return fn;
 }
+/**
+* Extract common request metadata from an Axios config.
+* Shared between the success and error response interceptors to avoid
+* duplicating the method/url/endpoint/duration extraction logic.
+*/
+function extractRequestMeta(config) {
+	const method = (config.method ?? "get").toUpperCase();
+	const url = config.url ?? "";
+	const endpoint = url.split("?")[0] ?? url;
+	const now = Date.now();
+	return {
+		method,
+		url,
+		endpoint,
+		durationMs: now - (config._startTime ?? now)
+	};
+}
+/**
+* Finalize a traced span and record metrics for a completed HTTP request.
+*/
+function finalizeRequestTrace(opts) {
+	const { span, statusCode, durationMs, method, endpoint, error } = opts;
+	if (span) {
+		span.setAttribute("http.status_code", statusCode);
+		span.setAttribute("http.response.duration_ms", durationMs);
+		if (error) {
+			span.setStatus({ code: SpanStatusCode.ERROR });
+			span.recordException(error);
+		} else span.setStatus({ code: SpanStatusCode.OK });
+		span.end();
+	}
+	apiCalls.add(1, {
+		method,
+		endpoint,
+		status_code: statusCode
+	});
+	apiDuration.record(durationMs, {
+		method,
+		endpoint
+	});
+}
 function createClient$1(apiKey, baseUrl = "https://api.hevyapp.com") {
 	const axiosInstance = axios.create({
 		baseURL: baseUrl,
 		headers: { "api-key": apiKey }
 	});
+	axiosInstance.interceptors.request.use((config) => {
+		const tracedConfig = config;
+		const method = (config.method ?? "get").toUpperCase();
+		const url = config.url ?? "";
+		const endpoint = url.split("?")[0] ?? url;
+		tracedConfig._span = tracer.startSpan(`hevy.api.${method}`, { attributes: {
+			"http.method": method,
+			"http.url": url,
+			"http.base_url": config.baseURL ?? "",
+			"hevy.api.endpoint": endpoint
+		} });
+		tracedConfig._startTime = Date.now();
+		return config;
+	});
+	axiosInstance.interceptors.response.use((response) => {
+		const tracedConfig = response.config;
+		const { method, endpoint, durationMs } = extractRequestMeta({
+			method: response.config.method,
+			url: response.config.url,
+			_startTime: tracedConfig._startTime
+		});
+		finalizeRequestTrace({
+			span: tracedConfig._span,
+			statusCode: response.status,
+			durationMs,
+			method,
+			endpoint
+		});
+		return response;
+	}, (error) => {
+		const tracedConfig = error.config ?? {};
+		const { method, endpoint, durationMs } = extractRequestMeta({
+			method: error.config?.method,
+			url: error.config?.url,
+			_startTime: tracedConfig._startTime
+		});
+		finalizeRequestTrace({
+			span: tracedConfig._span,
+			statusCode: error.response?.status ?? 0,
+			durationMs,
+			method,
+			endpoint,
+			error
+		});
+		throw error;
+	});
 	const headers = { "api-key": apiKey };
 	const client = axiosInstance;
 	return {
@@ -1741,32 +1941,28 @@ function deserializeMessageWithObservability(line, chunkSnapshot) {
 	const lineHadLeadingBom = line.startsWith(UTF8_BOM);
 	const normalizedLine = lineHadLeadingBom ? line.slice(1) : line;
 	const lineByteLength = Buffer.byteLength(line);
-	return Sentry.startSpan({
-		name: "mcp.stdio.deserialize",
-		op: "mcp.stdio.parse",
-		attributes: {
-			"mcp.transport": "stdio",
-			"mcp.stdio.parse.line.char_length": line.length,
-			"mcp.stdio.parse.line.byte_length": lineByteLength,
-			"mcp.stdio.parse.line.had_leading_bom": lineHadLeadingBom,
-			"mcp.stdio.parse.line.bom_stripped": lineHadLeadingBom,
-			"mcp.stdio.parse.chunk.last_byte_length": chunkSnapshot.lastChunkByteLength,
-			"mcp.stdio.parse.chunk.last_had_utf8_bom": chunkSnapshot.lastChunkStartsWithUtf8Bom
-		}
-	}, (span) => {
+	return tracer.startActiveSpan("mcp.stdio.deserialize", { attributes: {
+		"mcp.transport": "stdio",
+		"mcp.stdio.parse.line.char_length": line.length,
+		"mcp.stdio.parse.line.byte_length": lineByteLength,
+		"mcp.stdio.parse.line.had_leading_bom": lineHadLeadingBom,
+		"mcp.stdio.parse.line.bom_stripped": lineHadLeadingBom,
+		"mcp.stdio.parse.chunk.last_byte_length": chunkSnapshot.lastChunkByteLength,
+		"mcp.stdio.parse.chunk.last_had_utf8_bom": chunkSnapshot.lastChunkStartsWithUtf8Bom
+	} }, (span) => {
 		try {
 			const message = deserializeMessage(normalizedLine);
-			span.setStatus({ code: 1 });
+			span.setStatus({ code: SpanStatusCode.OK });
+			if (message && typeof message === "object" && "method" in message) span.setAttribute("mcp.method", String(message.method));
 			return message;
 		} catch (error) {
 			const failurePosition = parseFailurePosition(error);
 			const failureLocation = getFailureLocation(failurePosition, lineHadLeadingBom);
-			span.setStatus({
-				code: 2,
-				message: "invalid_json"
-			});
+			span.setStatus({ code: SpanStatusCode.ERROR });
+			span.recordException(error);
 			span.setAttribute("mcp.stdio.parse.failure.location", failureLocation);
 			if (failurePosition !== null) span.setAttribute("mcp.stdio.parse.failure.position", failurePosition);
+			stdioParseErrors.add(1, { failure_location: failureLocation });
 			Sentry.withScope((scope) => {
 				scope.setTag("mcp.transport", "stdio");
 				scope.setTag("mcp.stdio.parse.failure.location", failureLocation);
@@ -1785,6 +1981,8 @@ function deserializeMessageWithObservability(line, chunkSnapshot) {
 				Sentry.captureException(error);
 			});
 			throw error;
+		} finally {
+			span.end();
 		}
 	});
 }
@@ -1817,15 +2015,8 @@ function createInstrumentedStdioTransport(transport) {
 }
 //#endregion
 //#region src/index.ts
-const name = "hevy-mcp";
-const version = "1.25.17";
-const sentryConfig = {
-	dsn: "https://ce696d8333b507acbf5203eb877bce0f@o4508975499575296.ingest.de.sentry.io/4509049671647312",
-	release: process.env.SENTRY_RELEASE ?? `${name}@${version}`,
-	tracesSampleRate: 1,
-	sendDefaultPii: false
-};
-Sentry.init(sentryConfig);
+const name = name$1;
+const version = version$1;
 const HEVY_API_BASEURL = "https://api.hevyapp.com";
 const SENTRY_USER_ID_CONTEXT = "hevy-mcp:sentry-user-id:v1";
 function fingerprintApiKey(apiKey) {
@@ -1834,39 +2025,49 @@ function fingerprintApiKey(apiKey) {
 const serverConfigSchema = z.object({ apiKey: z.string().min(1, "Hevy API key is required").describe("Your Hevy API key (available in the Hevy app settings).") });
 const configSchema = serverConfigSchema;
 function buildServer(apiKey) {
-	return Sentry.startSpan({
-		name: "mcp.server.build",
-		op: "mcp.lifecycle.build",
-		attributes: {
-			"mcp.server.name": name,
-			"mcp.server.version": version,
-			"mcp.transport": "stdio"
+	const userId = fingerprintApiKey(apiKey);
+	return tracer.startActiveSpan("mcp.server.build", { attributes: {
+		"mcp.server.name": name,
+		"mcp.server.version": version,
+		"mcp.transport": "stdio",
+		"user.id": userId
+	} }, (span) => {
+		try {
+			Sentry.setUser({ id: userId });
+			setCurrentUserId(userId);
+			const baseServer = new McpServer({
+				name,
+				version
+			});
+			const server = Sentry.wrapMcpServerWithSentry(baseServer);
+			const hevyClient = tracer.startActiveSpan("mcp.hevy-client.initialize", (childSpan) => {
+				try {
+					return createClient(apiKey, HEVY_API_BASEURL);
+				} finally {
+					childSpan.end();
+				}
+			});
+			console.error("Hevy client initialized with API key");
+			tracer.startActiveSpan("mcp.tools.register", { attributes: { "mcp.tools.count": 6 } }, (toolsSpan) => {
+				try {
+					registerWorkoutTools(server, hevyClient);
+					registerRoutineTools(server, hevyClient);
+					registerTemplateTools(server, hevyClient);
+					registerFolderTools(server, hevyClient);
+					registerBodyMeasurementTools(server, hevyClient);
+					registerUserTools(server, hevyClient);
+				} finally {
+					toolsSpan.end();
+				}
+			});
+			span.setStatus({ code: SpanStatusCode.OK });
+			return server;
+		} catch (e) {
+			span.setStatus({ code: SpanStatusCode.ERROR });
+			throw e;
+		} finally {
+			span.end();
 		}
-	}, () => {
-		Sentry.setUser({ id: fingerprintApiKey(apiKey) });
-		const baseServer = new McpServer({
-			name,
-			version
-		});
-		const server = Sentry.wrapMcpServerWithSentry(baseServer);
-		const hevyClient = Sentry.startSpan({
-			name: "mcp.hevy-client.initialize",
-			op: "mcp.lifecycle.client.init"
-		}, () => createClient(apiKey, HEVY_API_BASEURL));
-		console.error("Hevy client initialized with API key");
-		Sentry.startSpan({
-			name: "mcp.tools.register",
-			op: "mcp.lifecycle.tools.register",
-			attributes: { "mcp.tools.count": 6 }
-		}, () => {
-			registerWorkoutTools(server, hevyClient);
-			registerRoutineTools(server, hevyClient);
-			registerTemplateTools(server, hevyClient);
-			registerFolderTools(server, hevyClient);
-			registerBodyMeasurementTools(server, hevyClient);
-			registerUserTools(server, hevyClient);
-		});
-		return server;
 	});
 }
 function createServer({ config }) {
@@ -1874,26 +2075,35 @@ function createServer({ config }) {
 	return buildServer(apiKey);
 }
 async function runServer() {
-	await Sentry.startSpan({
-		name: "mcp.server.run",
-		op: "mcp.lifecycle.run",
-		attributes: { "mcp.transport": "stdio" }
-	}, async () => {
-		const apiKey = parseConfig(process.argv.slice(2), process.env).apiKey;
-		assertApiKey(apiKey);
-		const server = buildServer(apiKey);
-		console.error("Starting MCP server in stdio mode");
-		const transport = createInstrumentedStdioTransport(new StdioServerTransport());
-		await Sentry.startSpan({
-			name: "mcp.server.connect",
-			op: "mcp.lifecycle.connect",
-			attributes: { "mcp.transport": "stdio" }
-		}, async () => {
-			await server.connect(transport);
-		});
+	serverStartups.add(1, { version });
+	await tracer.startActiveSpan("mcp.server.run", { attributes: { "mcp.transport": "stdio" } }, async (span) => {
+		try {
+			const apiKey = parseConfig(process.argv.slice(2), process.env).apiKey;
+			assertApiKey(apiKey);
+			const server = buildServer(apiKey);
+			console.error("Starting MCP server in stdio mode");
+			const transport = createInstrumentedStdioTransport(new StdioServerTransport());
+			await tracer.startActiveSpan("mcp.server.connect", { attributes: { "mcp.transport": "stdio" } }, async (connectSpan) => {
+				try {
+					await server.connect(transport);
+					connectSpan.setStatus({ code: SpanStatusCode.OK });
+				} catch (e) {
+					connectSpan.setStatus({ code: SpanStatusCode.ERROR });
+					throw e;
+				} finally {
+					connectSpan.end();
+				}
+			});
+			span.setStatus({ code: SpanStatusCode.OK });
+		} catch (e) {
+			span.setStatus({ code: SpanStatusCode.ERROR });
+			throw e;
+		} finally {
+			span.end();
+		}
 	});
 }
 //#endregion
 export { createServer as n, runServer as r, configSchema as t };
 
-//# sourceMappingURL=src-1TMPprRG.mjs.map
+//# sourceMappingURL=src-Di7keTQA.mjs.map