hevy-mcp 5.0.4 → 5.0.5

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@5.0.4" };
+		e.SENTRY_RELEASE = { id: "hevy-mcp@5.0.5" };
 		var n = new e.Error().stack;
 		n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "625c4c9c-e20d-40b3-96b1-4e799ef130f3", e._sentryDebugIdIdentifier = "sentry-dbid-625c4c9c-e20d-40b3-96b1-4e799ef130f3");
 	} catch (e) {}
 })();
-import { a as createSafeErrorDiagnostic, i as MissingHevyApiKeyError, n as runServer, o as flushTelemetry } from "./src-CJRjsomO.mjs";
+import { a as createSafeErrorDiagnostic, i as MissingHevyApiKeyError, n as runServer, o as flushTelemetry } from "./src-TBD9ENR3.mjs";
 //#region src/cli.ts
 runServer().catch(async (error) => {
 	if (error instanceof MissingHevyApiKeyError) console.error(error.message);

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@5.0.4" };
+		e.SENTRY_RELEASE = { id: "hevy-mcp@5.0.5" };
 		var n = new e.Error().stack;
 		n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "e9496b31-626b-4ad1-9416-47ba4ffd2995", e._sentryDebugIdIdentifier = "sentry-dbid-e9496b31-626b-4ad1-9416-47ba4ffd2995");
 	} catch (e) {}
 })();
-import { n as runServer, r as runStdioServer, t as createNodeMcpServer } from "./src-CJRjsomO.mjs";
+import { n as runServer, r as runStdioServer, t as createNodeMcpServer } from "./src-TBD9ENR3.mjs";
 export { createNodeMcpServer, runServer, runStdioServer };

package/dist/{src-CJRjsomO.mjs → src-TBD9ENR3.mjs}

@@ -4,9 +4,9 @@
 (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@5.0.4" };
+		e.SENTRY_RELEASE = { id: "hevy-mcp@5.0.5" };
 		var n = new e.Error().stack;
-		n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "72e7b08a-987c-4dba-aabd-6437da54ce2f", e._sentryDebugIdIdentifier = "sentry-dbid-72e7b08a-987c-4dba-aabd-6437da54ce2f");
+		n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "f5270278-73ea-40fd-92e2-2ae5127e6780", e._sentryDebugIdIdentifier = "sentry-dbid-f5270278-73ea-40fd-92e2-2ae5127e6780");
 	} catch (e) {}
 })();
 import { createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
@@ -20,13 +20,13 @@ import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
 import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
-import { AsyncLocalStorage } from "node:async_hooks";
 import { ZodError, z } from "zod";
 import { McpServer, deserializeMessage } from "@modelcontextprotocol/server";
 import { z as z$1 } from "zod/v4";
 import { isIP } from "node:net";
 import { createServer } from "node:http";
 import { NodeStreamableHTTPServerTransport } from "@modelcontextprotocol/node";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
@@ -79,6 +79,10 @@ function sanitizeSentryMcpSpan(span) {
 * Sentry SDK: error events, performance traces, release tracking
 * OTel Collector → Honeycomb: performance traces, metrics
 */
+const PROCESS_FAILURE_TAXONOMY = {
+	uncaughtException: "uncaught_exception",
+	unhandledRejection: "unhandled_rejection"
+};
 const SAFE_EXCEPTION_TYPES = /* @__PURE__ */ new Set([
 	"AggregateError",
 	"DOMException",
@@ -109,10 +113,7 @@ const SAFE_EXCEPTION_CODES = /* @__PURE__ */ new Set([
 ]);
 function normalizeTelemetryError(error) {
 	const candidate = error instanceof Error && typeof error.name === "string" ? error.name : void 0;
-	return {
-		name: candidate && SAFE_EXCEPTION_TYPES.has(candidate) ? candidate : "UnknownError",
-		...error instanceof Error && error.stack ? { stack: error.stack } : {}
-	};
+	return { name: candidate && SAFE_EXCEPTION_TYPES.has(candidate) ? candidate : "UnknownError" };
 }
 function getSafeExceptionCode(error) {
 	if (!error || typeof error !== "object" || !("code" in error)) return void 0;
@@ -125,7 +126,10 @@ function recordTelemetryException(error, attributes, span) {
 		const target = span ?? trace.getActiveSpan();
 		if (!target) return;
 		const normalized = normalizeTelemetryError(error);
-		target.recordException(normalized);
+		target.addEvent("exception", {
+			...attributes,
+			"exception.type": normalized.name
+		});
 		target.setAttribute("exception.type", normalized.name);
 		target.setAttribute("error.category", normalized.name);
 		if (attributes) target.setAttributes(attributes);
@@ -138,11 +142,12 @@ function installProcessExceptionTracking(processLike = process) {
 		try {
 			tracer.startActiveSpan(`mcp.process.${source}`, { attributes: { "mcp.span.category": "process" } }, (span) => {
 				try {
-					const normalized = normalizeTelemetryError(error);
 					const code = getSafeExceptionCode(error);
 					recordTelemetryException(error, {
 						"exception.source": source,
-						"error.category": normalized.name,
+						"mcp.failure.phase": PROCESS_FAILURE_TAXONOMY[source],
+						"error.type": "MCP_PROCESS_EXCEPTION",
+						"error.category": "McpProcessFailure",
 						...code ? { "error.code": code } : {}
 					}, span);
 				} finally {
@@ -164,7 +169,7 @@ function installProcessExceptionTracking(processLike = process) {
 	};
 }
 const name$1 = "hevy-mcp";
-const version$1 = "5.0.4";
+const version$1 = "5.0.5";
 const telemetryEnabled = process.env.HEVY_MCP_TELEMETRY !== "0";
 const collectorToken = "NH9vOela-HYreQxAbJa68cjEmORoEKM57EvneUDVcOo";
 const COLLECTOR_ENDPOINT = "https://otel.chrisdoc.dev/v1";
@@ -2839,7 +2844,7 @@ function registerHevyResources(server, runtime) {
 //#endregion
 //#region ../core/src/server-metadata.ts
 const SERVER_NAME = "hevy-mcp";
-const SERVER_VERSION = "5.0.4";
+const SERVER_VERSION = "5.0.5";
 const SERVER_INSTRUCTIONS = [
 	"Hevy MCP connects clients to the authenticated user's Hevy workout-tracking data, including workouts, routines, exercise templates, routine folders, body measurements, and profile information. HEVY_API_KEY must contain a valid Hevy API key for local stdio use.",
 	"Safety: all get-* and search-* tools are read-only. create-* and update-* tools mutate Hevy data. Creates are additive and non-idempotent, so repeating one can create duplicates. Updates can overwrite existing data. Delete operations are not available.",
@@ -5728,6 +5733,177 @@ function createInstrumentedStdioTransport(transport) {
 	return transport;
 }
 //#endregion
+//#region src/utils/sdk-observability.ts
+const sdkToolNameStorage = new AsyncLocalStorage();
+const SAFE_TOOL_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u;
+const SDK_FAILURE_TAXONOMY = {
+	protocol: {
+		errorType: "UNKNOWN_ERROR",
+		errorCategory: "McpSdkProtocolFailure"
+	},
+	tool_call: {
+		errorType: "UNKNOWN_ERROR",
+		errorCategory: "McpSdkToolCallFailure"
+	},
+	validation: {
+		errorType: "VALIDATION_ERROR",
+		errorCategory: "McpSdkValidationFailure"
+	}
+};
+function createFailureAttributes(error, phase, errorType, errorCategory) {
+	const diagnostic = createSafeErrorDiagnostic(error);
+	return {
+		"mcp.failure.phase": phase,
+		"error.type": errorType,
+		"error.category": errorCategory,
+		...diagnostic.code ? { "error.code": diagnostic.code } : {},
+		...diagnostic.status !== void 0 ? { "http.response.status_code": diagnostic.status } : {},
+		...diagnostic.method ? { "http.request.method": diagnostic.method } : {},
+		...diagnostic.endpoint ? { "hevy.api.endpoint": diagnostic.endpoint } : {}
+	};
+}
+function enrichActiveSdkSpan(attributes) {
+	try {
+		trace.getActiveSpan()?.setAttributes(attributes);
+	} catch {}
+}
+function getSdkToolName(request) {
+	if (!request || typeof request !== "object") return "unknown";
+	const candidate = request.params?.name;
+	return typeof candidate === "string" && SAFE_TOOL_NAME_PATTERN.test(candidate) ? candidate : "unknown";
+}
+function markSdkToolFailure(span, error, toolName = sdkToolNameStorage.getStore() ?? "unknown", kind = "tool_call") {
+	const taxonomy = SDK_FAILURE_TAXONOMY[kind];
+	const attributes = createFailureAttributes(error, "sdk", taxonomy.errorType, taxonomy.errorCategory);
+	span.addEvent("mcp.tool.failure", {
+		"mcp.tool.name": toolName,
+		...attributes
+	});
+	span.setAttribute("error.type", taxonomy.errorType);
+	recordTelemetryException(error, attributes, span);
+	span.setStatus({ code: SpanStatusCode.ERROR });
+}
+function installProtocolErrorTracking(server, transport) {
+	const protocol = server.server;
+	if (!protocol) return;
+	const previous = protocol.onerror;
+	protocol.onerror = (error) => {
+		const taxonomy = SDK_FAILURE_TAXONOMY.protocol;
+		const attributes = createFailureAttributes(error, "sdk", taxonomy.errorType, taxonomy.errorCategory);
+		const activeSpan = trace.getActiveSpan();
+		const sessionId = getCurrentMcpSessionId();
+		if (activeSpan) {
+			activeSpan.addEvent("mcp.tool.failure", {
+				"mcp.tool.name": sdkToolNameStorage.getStore() ?? "unknown",
+				...attributes
+			});
+			recordTelemetryException(error, attributes, activeSpan);
+		} else tracer.startActiveSpan("mcp.sdk.failure", { attributes: {
+			"mcp.span.category": "protocol",
+			"mcp.transport": transport,
+			...sessionId ? { "mcp.session.id": sessionId } : {}
+		} }, (span) => {
+			span.addEvent("mcp.tool.failure", {
+				"mcp.tool.name": "unknown",
+				...attributes
+			});
+			recordTelemetryException(error, attributes, span);
+			span.end();
+		});
+		try {
+			previous?.(error);
+		} catch {}
+	};
+}
+function installValidationErrorTracking(server) {
+	const toolErrorHost = server;
+	const previousCreateToolError = toolErrorHost.createToolError;
+	if (!previousCreateToolError) return;
+	const createToolError = previousCreateToolError.bind(server);
+	toolErrorHost.createToolError = (message) => {
+		const result = createToolError(message);
+		const activeSpan = trace.getActiveSpan();
+		if (activeSpan) markSdkToolFailure(activeSpan, /* @__PURE__ */ new Error("MCP tool validation failed"), void 0, "validation");
+		return result;
+	};
+}
+function installInitializeEnrichment(handlers, transport) {
+	const initializeHandler = handlers.get("initialize");
+	if (!initializeHandler) return;
+	handlers.set("initialize", (request, extra) => {
+		enrichActiveSdkSpan({
+			"mcp.span.category": "protocol",
+			"mcp.transport": transport
+		});
+		return initializeHandler(request, extra);
+	});
+}
+function installToolCallTracking(handlers, transport) {
+	const toolHandler = handlers.get("tools/call");
+	if (!toolHandler) return;
+	handlers.set("tools/call", (request, extra) => {
+		const sessionId = getCurrentMcpSessionId();
+		const toolName = getSdkToolName(request);
+		const attributes = {
+			"mcp.span.category": "protocol",
+			"mcp.transport": transport,
+			"mcp.operation.kind": "tool",
+			"mcp.tool.name": toolName,
+			...sessionId ? { "mcp.session.id": sessionId } : {}
+		};
+		enrichActiveSdkSpan(attributes);
+		return sdkToolNameStorage.run(toolName, () => tracer.startActiveSpan("mcp.sdk.tools.call", { attributes }, async (span) => {
+			try {
+				const result = await toolHandler(request, extra);
+				if (result?.isError === true) {
+					span.setAttribute("mcp.tool.outcome", "returned_error");
+					span.setStatus({ code: SpanStatusCode.ERROR });
+				} else span.setStatus({ code: SpanStatusCode.OK });
+				return result;
+			} catch (error) {
+				markSdkToolFailure(span, error, toolName);
+				throw error;
+			} finally {
+				span.end();
+			}
+		}));
+	});
+}
+function installDiscoveryTracking(handlers) {
+	const discoveryHandler = handlers.get("server/discover");
+	if (!discoveryHandler) return;
+	handlers.set("server/discover", (request, extra) => {
+		const sessionId = getCurrentMcpSessionId();
+		return tracer.startActiveSpan("mcp.server.discover", { attributes: {
+			"mcp.span.category": "discovery",
+			"mcp.transport": getCurrentMcpTransport(),
+			...sessionId ? { "mcp.session.id": sessionId } : {}
+		} }, async (span) => {
+			try {
+				const result = await discoveryHandler(request, extra);
+				span.setStatus({ code: SpanStatusCode.OK });
+				return result;
+			} catch (error) {
+				const attributes = createFailureAttributes(error, "discovery", "UNKNOWN_ERROR", "McpServerDiscoveryFailure");
+				span.addEvent("mcp.discovery.failure", attributes);
+				recordTelemetryException(error, attributes, span);
+				throw error;
+			} finally {
+				span.end();
+			}
+		});
+	});
+}
+function installSdkErrorTracking(server, transport) {
+	installProtocolErrorTracking(server, transport);
+	installValidationErrorTracking(server);
+	const handlers = server.server?._requestHandlers;
+	if (!(handlers instanceof Map)) return;
+	installInitializeEnrichment(handlers, transport);
+	installToolCallTracking(handlers, transport);
+	installDiscoveryTracking(handlers);
+}
+//#endregion
 //#region src/utils/version-check.ts
 const CACHE_TTL_MS = 1440 * 60 * 1e3;
 const REQUEST_TIMEOUT_MS = 3e3;
@@ -5917,158 +6093,45 @@ function getSafeValidationDiagnostic(error) {
 	const code = error.code;
 	return typeof code === "string" && SAFE_NETWORK_ERROR_CODES.has(code) ? code : void 0;
 }
-function recordLifecycleFailure(span, error, phase) {
+const LIFECYCLE_FAILURE_TAXONOMY = {
+	config: {
+		errorType: "MCP_SERVER_CONFIG_ERROR",
+		errorCategory: "McpServerConfigFailure"
+	},
+	api_key_validation: {
+		errorType: "MCP_API_KEY_VALIDATION_ERROR",
+		errorCategory: "McpApiKeyValidationFailure"
+	},
+	build: {
+		errorType: "MCP_SERVER_BUILD_ERROR",
+		errorCategory: "McpServerBuildFailure"
+	},
+	connect: {
+		errorType: "MCP_TRANSPORT_CONNECT_ERROR",
+		errorCategory: "McpTransportConnectFailure"
+	},
+	run: {
+		errorType: "MCP_SERVER_RUN_ERROR",
+		errorCategory: "McpServerRunFailure"
+	}
+};
+function createLifecycleFailureAttributes(error, phase) {
 	const diagnostic = createSafeErrorDiagnostic(error);
-	const attributes = {
+	const taxonomy = LIFECYCLE_FAILURE_TAXONOMY[phase];
+	return {
 		"mcp.failure.phase": phase,
-		"error.type": diagnostic.category,
-		"error.category": diagnostic.category,
+		"error.type": taxonomy.errorType,
+		"error.category": taxonomy.errorCategory,
 		...diagnostic.code ? { "error.code": diagnostic.code } : {},
 		...diagnostic.status !== void 0 ? { "http.response.status_code": diagnostic.status } : {},
 		...diagnostic.method ? { "http.request.method": diagnostic.method } : {},
 		...diagnostic.endpoint ? { "hevy.api.endpoint": diagnostic.endpoint } : {}
 	};
-	span.addEvent("mcp.lifecycle.failure", {
-		"error.type": diagnostic.category,
-		"error.category": diagnostic.category,
-		...diagnostic.code ? { "error.code": diagnostic.code } : {}
-	});
-	recordTelemetryException(error, attributes, span);
-}
-const sdkToolNameStorage = new AsyncLocalStorage();
-const SAFE_TOOL_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u;
-function getSdkToolName(request) {
-	if (!request || typeof request !== "object") return "unknown";
-	const candidate = request.params?.name;
-	return typeof candidate === "string" && SAFE_TOOL_NAME_PATTERN.test(candidate) ? candidate : "unknown";
-}
-function markSdkToolFailure(span, error, toolName = sdkToolNameStorage.getStore() ?? "unknown", errorTypeOverride) {
-	const diagnostic = createSafeErrorDiagnostic(error);
-	const errorType = errorTypeOverride ?? diagnostic.category;
-	span.addEvent("mcp.tool.failure", {
-		"mcp.tool.name": toolName,
-		"error.type": errorType,
-		"error.category": diagnostic.category,
-		...diagnostic.code ? { "error.code": diagnostic.code } : {},
-		...diagnostic.status !== void 0 ? { "http.response.status_code": diagnostic.status } : {},
-		...diagnostic.method ? { "http.request.method": diagnostic.method } : {},
-		...diagnostic.endpoint ? { "hevy.api.endpoint": diagnostic.endpoint } : {}
-	});
-	span.setAttribute("error.type", errorType);
-	recordTelemetryException(error, {
-		"mcp.failure.phase": "sdk",
-		"error.type": errorType,
-		"error.category": diagnostic.category,
-		...diagnostic.code ? { "error.code": diagnostic.code } : {},
-		...diagnostic.status !== void 0 ? { "http.response.status_code": diagnostic.status } : {}
-	}, span);
-	span.setStatus({ code: SpanStatusCode.ERROR });
 }
-function installSdkErrorTracking(server) {
-	const protocol = server.server;
-	if (!protocol) return;
-	const previous = protocol.onerror;
-	protocol.onerror = (error) => {
-		const diagnostic = createSafeErrorDiagnostic(error);
-		const attributes = {
-			"mcp.failure.phase": "sdk",
-			"error.category": diagnostic.category,
-			...diagnostic.code ? { "error.code": diagnostic.code } : {},
-			...diagnostic.status !== void 0 ? { "http.response.status_code": diagnostic.status } : {}
-		};
-		const activeSpan = trace.getActiveSpan();
-		const sessionId = getCurrentMcpSessionId();
-		if (activeSpan) {
-			activeSpan.addEvent("mcp.tool.failure", {
-				"mcp.tool.name": sdkToolNameStorage.getStore() ?? "unknown",
-				"error.type": "UNKNOWN_ERROR",
-				"error.category": diagnostic.category,
-				...diagnostic.code ? { "error.code": diagnostic.code } : {}
-			});
-			recordTelemetryException(error, attributes, activeSpan);
-		} else tracer.startActiveSpan("mcp.sdk.failure", { attributes: { ...sessionId ? { "mcp.session.id": sessionId } : {} } }, (span) => {
-			span.addEvent("mcp.tool.failure", {
-				"mcp.tool.name": "unknown",
-				"error.type": "UNKNOWN_ERROR",
-				"error.category": diagnostic.category,
-				...diagnostic.code ? { "error.code": diagnostic.code } : {}
-			});
-			recordTelemetryException(error, attributes, span);
-			span.end();
-		});
-		try {
-			previous?.(error);
-		} catch {}
-	};
-	const toolErrorHost = server;
-	const previousCreateToolError = toolErrorHost.createToolError;
-	if (previousCreateToolError) {
-		const createToolError = previousCreateToolError.bind(server);
-		toolErrorHost.createToolError = (message) => {
-			const result = createToolError(message);
-			const activeSpan = trace.getActiveSpan();
-			if (activeSpan) markSdkToolFailure(activeSpan, /* @__PURE__ */ new Error("MCP tool validation failed"), void 0, "VALIDATION_ERROR");
-			return result;
-		};
-	}
-	const handlers = protocol._requestHandlers;
-	if (!(handlers instanceof Map)) return;
-	const toolHandler = handlers.get("tools/call");
-	if (toolHandler) handlers.set("tools/call", (request, extra) => {
-		const sessionId = getCurrentMcpSessionId();
-		const toolName = getSdkToolName(request);
-		return sdkToolNameStorage.run(toolName, () => tracer.startActiveSpan("mcp.sdk.tools.call", { attributes: {
-			"mcp.span.category": "protocol",
-			"mcp.operation.kind": "tool",
-			"mcp.tool.name": toolName,
-			...sessionId ? { "mcp.session.id": sessionId } : {}
-		} }, async (span) => {
-			try {
-				const result = await toolHandler(request, extra);
-				if (result?.isError === true) {
-					span.setAttribute("mcp.tool.outcome", "returned_error");
-					span.setStatus({ code: SpanStatusCode.ERROR });
-				} else span.setStatus({ code: SpanStatusCode.OK });
-				return result;
-			} catch (error) {
-				markSdkToolFailure(span, error, toolName);
-				throw error;
-			} finally {
-				span.end();
-			}
-		}));
-	});
-	const discoveryHandler = handlers.get("server/discover");
-	if (discoveryHandler) handlers.set("server/discover", (request, extra) => {
-		const sessionId = getCurrentMcpSessionId();
-		return tracer.startActiveSpan("mcp.server.discover", { attributes: {
-			"mcp.span.category": "discovery",
-			"mcp.transport": getCurrentMcpTransport(),
-			...sessionId ? { "mcp.session.id": sessionId } : {}
-		} }, async (span) => {
-			try {
-				const result = await discoveryHandler(request, extra);
-				span.setStatus({ code: SpanStatusCode.OK });
-				return result;
-			} catch (error) {
-				const diagnostic = createSafeErrorDiagnostic(error);
-				span.addEvent("mcp.discovery.failure", {
-					"error.type": diagnostic.category,
-					"error.category": diagnostic.category,
-					...diagnostic.code ? { "error.code": diagnostic.code } : {}
-				});
-				recordTelemetryException(error, {
-					"mcp.failure.phase": "discovery",
-					"error.type": diagnostic.category,
-					"error.category": diagnostic.category,
-					...diagnostic.code ? { "error.code": diagnostic.code } : {}
-				}, span);
-				throw error;
-			} finally {
-				span.end();
-			}
-		});
-	});
+function recordLifecycleFailure(span, error, phase) {
+	const attributes = createLifecycleFailureAttributes(error, phase);
+	span.addEvent("mcp.lifecycle.failure", attributes);
+	recordTelemetryException(error, attributes, span);
 }
 async function validateApiKey(apiKey) {
 	const startupProbeClient = createHevyClient({
@@ -6108,7 +6171,7 @@ function buildServer(apiKey, transport = "stdio") {
 				observer: createNodeToolObserver(),
 				cacheObserver: createNodeCacheObserver()
 			});
-			installSdkErrorTracking(server);
+			installSdkErrorTracking(server, transport);
 			console.error("Hevy client initialized with API key");
 			span.setStatus({ code: SpanStatusCode.OK });
 			return server;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "hevy-mcp",
-	"version": "5.0.4",
+	"version": "5.0.5",
 	"private": false,
 	"description": "A Model Context Protocol (MCP) server implementation that interfaces with the Hevy fitness tracking app and its API.",
 	"repository": {

package/server.json

@@ -7,12 +7,12 @@
 		"url": "https://github.com/chrisdoc/hevy-mcp",
 		"source": "github"
 	},
-	"version": "5.0.4",
+	"version": "5.0.5",
 	"packages": [
 		{
 			"registryType": "npm",
 			"identifier": "hevy-mcp",
-			"version": "5.0.4",
+			"version": "5.0.5",
 			"transport": {
 				"type": "stdio"
 			},