hevy-mcp 2.0.0 → 3.1.1

package/dist/{src-c3mB-R0m.mjs → src-CkkrTrrg.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@2.0.0" };
+		e.SENTRY_RELEASE = { id: "hevy-mcp@3.1.1" };
 		var n = new e.Error().stack;
-		n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "17d5086b-9850-447d-9372-27bb2ce5dcc5", e._sentryDebugIdIdentifier = "sentry-dbid-17d5086b-9850-447d-9372-27bb2ce5dcc5");
+		n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "c68eeb18-d351-49fe-9f67-3f26fa89bfdb", e._sentryDebugIdIdentifier = "sentry-dbid-c68eeb18-d351-49fe-9f67-3f26fa89bfdb");
 	} catch (e) {}
 })();
 import * as Sentry from "@sentry/node";
@@ -19,10 +19,9 @@ import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
 import { createHmac, randomUUID } 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 { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z as z$1 } from "zod/v4";
 import { deserializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js";
 import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
@@ -41,10 +40,10 @@ import semver from "semver";
 * OTel Collector → Honeycomb: performance traces, metrics
 */
 const name$1 = "hevy-mcp";
-const version$1 = "2.0.0";
+const version$1 = "3.1.1";
 const collectorToken = "NH9vOela-HYreQxAbJa68cjEmORoEKM57EvneUDVcOo";
 const COLLECTOR_ENDPOINT = "https://otel.chrisdoc.dev/v1";
-const sentryRelease = process.env.SENTRY_RELEASE ?? `hevy-mcp@2.0.0`;
+const sentryRelease = process.env.SENTRY_RELEASE ?? `hevy-mcp@3.1.1`;
 const resource = resourceFromAttributes({
 	"service.name": name$1,
 	"service.version": version$1
@@ -262,10 +261,8 @@ var AsyncTtlCache = class {
 //#endregion
 //#region src/utils/exercise-template-catalog.ts
 const EXERCISE_TEMPLATE_CATALOG_CACHE_KEY = "exercise-template-catalog";
-const exerciseTemplateCatalogCache = new AsyncTtlCache({
-	ttlMs: 300 * 1e3,
-	maxSize: 1
-});
+const EXERCISE_TEMPLATE_CATALOG_CACHE_TTL_MS = 300 * 1e3;
+const EXERCISE_TEMPLATE_CATALOG_CACHE_MAX_SIZE = 1;
 function getSafePageCount$1(data, currentPage) {
 	const pageCount = data?.page_count;
 	if (typeof pageCount !== "number" || !Number.isSafeInteger(pageCount) || pageCount < currentPage) return currentPage;
@@ -286,13 +283,179 @@ async function fetchExerciseTemplateCatalog(hevyClient) {
 	} while (page <= pageCount);
 	return allTemplates;
 }
-function getExerciseTemplateCatalog(hevyClient, options = {}) {
-	const reason = options.refresh ? "explicit-refresh" : exerciseTemplateCatalogCache.size === 0 ? "initial-load" : "ttl-expired";
-	return exerciseTemplateCatalogCache.getOrFetch(EXERCISE_TEMPLATE_CATALOG_CACHE_KEY, async () => {
-		const catalog = await fetchExerciseTemplateCatalog(hevyClient);
-		options.onRefreshed?.(catalog, reason);
-		return catalog;
-	}, options);
+/** Create a cache owned by one MCP server/request lifecycle. */
+function createExerciseTemplateCatalog() {
+	const cache = new AsyncTtlCache({
+		ttlMs: EXERCISE_TEMPLATE_CATALOG_CACHE_TTL_MS,
+		maxSize: EXERCISE_TEMPLATE_CATALOG_CACHE_MAX_SIZE
+	});
+	return {
+		get(hevyClient, options = {}) {
+			const reason = options.refresh ? "explicit-refresh" : cache.size === 0 ? "initial-load" : "ttl-expired";
+			return cache.getOrFetch(EXERCISE_TEMPLATE_CATALOG_CACHE_KEY, async () => {
+				const catalog = await fetchExerciseTemplateCatalog(hevyClient);
+				options.onRefreshed?.(catalog, reason);
+				return catalog;
+			}, options);
+		},
+		reset() {
+			cache.clear();
+		}
+	};
+}
+//#endregion
+//#region src/utils/hevy-http-error.ts
+const HEVY_RETRY_EXHAUSTED_ERROR_CODE = "HEVY_RETRY_EXHAUSTED";
+const HEVY_REQUEST_ABORTED_ERROR_CODE = "HEVY_REQUEST_ABORTED";
+/** Sanitized HTTP error that never contains credentials or full request URLs. */
+var HevyHttpError = class extends Error {
+	status;
+	statusText;
+	data;
+	headers;
+	method;
+	endpoint;
+	code;
+	hevyRetryCount;
+	hevyRetryExhausted;
+	constructor(message, options) {
+		super(message, { cause: options.cause });
+		this.name = "HevyHttpError";
+		this.status = options.status;
+		this.statusText = options.statusText;
+		this.data = options.data;
+		this.headers = options.headers;
+		this.method = options.method;
+		this.endpoint = options.endpoint;
+		this.code = options.code;
+	}
+};
+function isHevyHttpError(error) {
+	return error instanceof HevyHttpError;
+}
+//#endregion
+//#region src/utils/safe-error-diagnostic.ts
+const SAFE_ERROR_CODES = /* @__PURE__ */ new Set([
+	"EAI_AGAIN",
+	"ECONNABORTED",
+	"ECONNREFUSED",
+	"ECONNRESET",
+	"ENETUNREACH",
+	"ENOTFOUND",
+	"ERR_NETWORK",
+	"ERR_SOCKET_TIMEOUT",
+	"ETIMEDOUT",
+	"HEVY_INVALID_ENDPOINT",
+	HEVY_REQUEST_ABORTED_ERROR_CODE,
+	HEVY_RETRY_EXHAUSTED_ERROR_CODE
+]);
+const SAFE_HTTP_METHODS = /* @__PURE__ */ new Set([
+	"DELETE",
+	"GET",
+	"HEAD",
+	"OPTIONS",
+	"PATCH",
+	"POST",
+	"PUT"
+]);
+const SAFE_ENDPOINTS = /* @__PURE__ */ new Set([
+	"unknown",
+	"/v1/body_measurements",
+	"/v1/body_measurements/:date",
+	"/v1/exercise_history/:exerciseTemplateId",
+	"/v1/exercise_templates",
+	"/v1/exercise_templates/:exerciseTemplateId",
+	"/v1/routine_folders",
+	"/v1/routine_folders/:folderId",
+	"/v1/routines",
+	"/v1/routines/:routineId",
+	"/v1/user/info",
+	"/v1/workouts",
+	"/v1/workouts/:workoutId",
+	"/v1/workouts/count",
+	"/v1/workouts/events"
+]);
+const SAFE_SOURCE_SUFFIXES = [
+	["/src/utils/error-handler.ts", "error-handler"],
+	["/src/utils/hevyClientKubb.ts", "hevy-client"],
+	["/src/index.ts", "index"],
+	["/src/utils/observability-wrapper.ts", "observability-wrapper"],
+	["/src/shared-server.ts", "shared-server"],
+	["/src/worker.ts", "worker"]
+];
+const PROJECT_PATH_MARKER = "/hevy-mcp/";
+const MAX_STACK_POSITION = 1e6;
+function classifyError(error) {
+	if (isHevyHttpError(error)) return "HevyHttpError";
+	if (error instanceof TypeError) return "TypeError";
+	if (error instanceof RangeError) return "RangeError";
+	if (error instanceof ReferenceError) return "ReferenceError";
+	if (error instanceof SyntaxError) return "SyntaxError";
+	if (error instanceof URIError) return "URIError";
+	if (error instanceof EvalError) return "EvalError";
+	if (error instanceof AggregateError) return "AggregateError";
+	if (typeof DOMException !== "undefined" && error instanceof DOMException) return "DOMException";
+	if (error instanceof Error) return "Error";
+	return "UnknownError";
+}
+function getSafeCode(error) {
+	if (!error || typeof error !== "object" || !("code" in error)) return;
+	const code = error.code;
+	return typeof code === "string" && SAFE_ERROR_CODES.has(code) ? code : void 0;
+}
+function getSafeStatus(error) {
+	if (!isHevyHttpError(error)) return void 0;
+	return error.status !== void 0 && Number.isInteger(error.status) && error.status >= 100 && error.status <= 599 ? error.status : void 0;
+}
+function getSafeMethod(error) {
+	if (!isHevyHttpError(error)) return void 0;
+	const method = error.method.toUpperCase();
+	return SAFE_HTTP_METHODS.has(method) ? method : void 0;
+}
+function getSafeEndpoint(error) {
+	if (!isHevyHttpError(error)) return void 0;
+	return SAFE_ENDPOINTS.has(error.endpoint) ? error.endpoint : void 0;
+}
+function parseSafeStackFrames(error) {
+	if (!(error instanceof Error) || typeof error.stack !== "string") return;
+	const frames = [];
+	for (const frameLine of error.stack.split("\n").slice(1)) {
+		const match = /^\s{4}at (?:[^()\r\n]+ \()?([^()\s\r\n]+):(\d+):(\d+)\)?$/.exec(frameLine);
+		if (!match) continue;
+		const [, rawSource, rawLine, rawColumn] = match;
+		if (!rawSource || !rawLine || !rawColumn) continue;
+		if (rawSource.includes("?") || rawSource.includes("#") || !rawSource.startsWith("/") && !rawSource.startsWith("file:///") || !rawSource.includes(PROJECT_PATH_MARKER)) continue;
+		const source = SAFE_SOURCE_SUFFIXES.find(([suffix]) => rawSource.endsWith(suffix))?.[1];
+		if (!source) continue;
+		const line = Number(rawLine);
+		const column = Number(rawColumn);
+		if (!Number.isSafeInteger(line) || !Number.isSafeInteger(column) || line < 1 || column < 1 || line > MAX_STACK_POSITION || column > MAX_STACK_POSITION) continue;
+		frames.push({
+			source,
+			line,
+			column
+		});
+		if (frames.length === 3) break;
+	}
+	return frames.length > 0 ? frames : void 0;
+}
+function createSafeErrorDiagnostic(error) {
+	try {
+		const diagnostic = { category: classifyError(error) };
+		const code = getSafeCode(error);
+		const status = getSafeStatus(error);
+		const method = getSafeMethod(error);
+		const endpoint = getSafeEndpoint(error);
+		const frames = parseSafeStackFrames(error);
+		if (code) diagnostic.code = code;
+		if (status !== void 0) diagnostic.status = status;
+		if (method) diagnostic.method = method;
+		if (endpoint) diagnostic.endpoint = endpoint;
+		if (frames) diagnostic.frames = frames;
+		return diagnostic;
+	} catch {
+		return { category: "UnknownError" };
+	}
 }
 //#endregion
 //#region src/utils/formatters.ts
@@ -405,7 +568,7 @@ function calculateDuration(startTime, endTime) {
 		if (durationMs < 0) return "Invalid duration (end time before start time)";
 		return `${Math.floor(durationMs / (1e3 * 60 * 60))}h ${Math.floor(durationMs % (1e3 * 60 * 60) / (1e3 * 60))}m ${Math.floor(durationMs % (1e3 * 60) / 1e3)}s`;
 	} catch (error) {
-		console.error("Error calculating duration:", error);
+		console.error("Error calculating duration", createSafeErrorDiagnostic(error));
 		return "Unknown duration";
 	}
 }
@@ -503,7 +666,7 @@ async function fetchAllRoutineFolders(hevyClient) {
 	} while (page <= pageCount);
 	return allFolders;
 }
-function registerHevyResources(server, hevyClient) {
+function registerHevyResources(server, hevyClient, catalog = createExerciseTemplateCatalog()) {
 	server.registerResource("user-profile", "hevy://user", {
 		description: "Authenticated Hevy user profile",
 		mimeType: JSON_MIME_TYPE
@@ -520,7 +683,8 @@ function registerHevyResources(server, hevyClient) {
 		description: "Full formatted Hevy exercise template catalog",
 		mimeType: JSON_MIME_TYPE
 	}, async (uri) => {
-		return createJsonResourceResult(uri, (await getExerciseTemplateCatalog(requireClient(hevyClient))).map(formatExerciseTemplate));
+		const client = requireClient(hevyClient);
+		return createJsonResourceResult(uri, (await catalog.get(client)).map(formatExerciseTemplate));
 	});
 	server.registerResource("routine-folders", "hevy://routine-folders", {
 		description: "Full formatted list of Hevy routine folders",
@@ -530,13 +694,24 @@ function registerHevyResources(server, hevyClient) {
 	});
 }
 //#endregion
+//#region src/server-metadata.ts
+const SERVER_NAME = "hevy-mcp";
+const SERVER_VERSION = "3.1.1";
+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.",
+	"Workflow: search exercise templates first, then use the returned template IDs when creating workouts or routines. To create a completed workout from a routine, fetch the routine as a plan, then obtain the actual completed sets and end time from the user; never invent completion data.",
+	"Pagination: start at page 1 and fetch only the pages needed. Most list tools allow pageSize up to 10; get-exercise-templates allows up to 100.",
+	"Rate limits and retries: minimize repeated calls. If Hevy returns HTTP 429, follow its retry guidance. Transient read requests retry automatically, but write requests do not; confirm uncertain write outcomes before trying again."
+].join("\n\n");
+//#endregion
 //#region src/utils/error-classification.ts
 /**
 * Determine the type of error based on error characteristics.
 */
 function determineErrorType(error, message) {
 	if (error !== null && typeof error === "object" && error.hevyRetryExhausted === true) return "NETWORK_ERROR";
-	if (isAxiosError(error) && error.response?.status === 429) return "RATE_LIMIT";
+	if (isHevyHttpError(error) && error.status === 429) return "RATE_LIMIT";
 	const messageLower = message.toLowerCase();
 	const nameLower = error instanceof Error ? error.name.toLowerCase() : "";
 	if (nameLower.includes("network") || messageLower.includes("network") || nameLower.includes("fetch") || messageLower.includes("fetch") || nameLower.includes("timeout") || messageLower.includes("timeout")) return "NETWORK_ERROR";
@@ -550,27 +725,26 @@ function determineErrorType(error, message) {
 /**
 * Centralized error handling utility for MCP tools
 */
-function normalizeHeaderValue$1(value) {
+function normalizeHeaderValue(value) {
 	if (typeof value === "string") {
 		const trimmed = value.trim();
 		return trimmed.length > 0 ? trimmed : void 0;
 	}
 	if (typeof value === "number" && Number.isFinite(value)) return String(value);
-	if (Array.isArray(value) && value.length > 0) return normalizeHeaderValue$1(value[0]);
+	if (Array.isArray(value) && value.length > 0) return normalizeHeaderValue(value[0]);
 }
-function getHeaderValue$1(headers, key) {
+function getHeaderValue(headers, key) {
 	if (!headers || typeof headers !== "object") return;
-	if ("get" in headers && typeof headers.get === "function") return normalizeHeaderValue$1(headers.get(key));
+	if ("get" in headers && typeof headers.get === "function") return normalizeHeaderValue(headers.get(key));
 	const headerRecord = headers;
-	return normalizeHeaderValue$1(headerRecord[key] ?? headerRecord[key.toLowerCase()] ?? headerRecord[key.toUpperCase()]);
+	return normalizeHeaderValue(headerRecord[key] ?? headerRecord[key.toLowerCase()] ?? headerRecord[key.toUpperCase()]);
 }
 function formatSecondsLabel(seconds) {
 	const roundedSeconds = Math.max(0, Math.round(seconds));
 	return `${roundedSeconds} second${roundedSeconds === 1 ? "" : "s"}`;
 }
 function getRateLimitMessage(error) {
-	if (!isAxiosError(error)) return "Rate limited by Hevy. Please wait and retry.";
-	const retryAfterHeader = getHeaderValue$1(error.response?.headers, "retry-after");
+	const retryAfterHeader = getHeaderValue(error.headers, "retry-after");
 	if (!retryAfterHeader) return "Rate limited by Hevy (HTTP 429). Please wait and retry your request.";
 	const seconds = Number(retryAfterHeader);
 	if (Number.isFinite(seconds) && seconds >= 0) return `Rate limited by Hevy (HTTP 429). Please wait about ${formatSecondsLabel(seconds)} before retrying.`;
@@ -588,8 +762,9 @@ function getRetryExhaustedMessage(error) {
 	return "Unable to complete the request after multiple attempts to the Hevy API due to transient failures. Please try again shortly.";
 }
 function getUserFacingMessage(error, defaultMessage) {
+	if (error instanceof Error && error.message === "API client not initialized. Please provide HEVY_API_KEY.") return HEVY_CLIENT_NOT_INITIALIZED_ERROR;
 	if (isRetryExhaustedError(error)) return getRetryExhaustedMessage(error);
-	if (isAxiosError(error) && error.response?.status === 429) return getRateLimitMessage(error);
+	if (isHevyHttpError(error) && error.status === 429) return getRateLimitMessage(error);
 	return defaultMessage;
 }
 /**
@@ -600,25 +775,28 @@ function getUserFacingMessage(error, defaultMessage) {
 * @returns A formatted MCP tool response with error information
 */
 function createErrorResponse(error, context) {
-	const originalErrorMessage = extractErrorMessage(error);
-	let errorMessage = originalErrorMessage;
-	const axiosErrorContext = extractAxiosErrorContext(error);
+	let errorMessage = "The request failed unexpectedly. Please try again.";
+	const safeDiagnostic = createSafeErrorDiagnostic(error);
+	const axiosErrorContext = safeDiagnostic.status !== void 0 || safeDiagnostic.method !== void 0 || safeDiagnostic.endpoint !== void 0 ? {
+		status: safeDiagnostic.status,
+		method: safeDiagnostic.method,
+		url: safeDiagnostic.endpoint
+	} : null;
 	const mappedHevyErrorMessage = mapHevyErrorMessageByStatus(axiosErrorContext?.status);
 	if (mappedHevyErrorMessage) errorMessage = mappedHevyErrorMessage;
-	if (!mappedHevyErrorMessage && axiosErrorContext?.data) errorMessage = stringifyErrorData(axiosErrorContext.data);
+	else if (isHevyHttpError(error) && error.status !== void 0) errorMessage = `Hevy API request failed (HTTP ${error.status}).`;
 	errorMessage = getUserFacingMessage(error, errorMessage);
-	const errorCode = error instanceof Error && "code" in error ? error.code : void 0;
+	const errorCode = safeDiagnostic.code;
 	const errorType = determineErrorType(error, errorMessage);
 	const errorContext = {
 		sourceContext: context,
-		originalErrorMessage,
+		originalErrorMessage: `${safeDiagnostic.category} occurred`,
 		errorCode,
 		errorType,
 		axios: axiosErrorContext ?? void 0
 	};
 	const formattedMessage = `${context ? `[${context}] ` : ""}Error: ${errorMessage}`;
-	const errorCodeSuffix = errorCode ? `, Code: ${errorCode}` : "";
-	console.error(`${formattedMessage} (Type: ${errorType}${errorCodeSuffix})`, error);
+	console.error("MCP tool failure", safeDiagnostic);
 	return {
 		content: [{
 			type: "text",
@@ -628,27 +806,6 @@ function createErrorResponse(error, context) {
 		errorContext
 	};
 }
-function extractErrorMessage(error) {
-	if (error instanceof Error) return error.message;
-	if (typeof error === "string") return error;
-	if (error && typeof error === "object" && "message" in error && typeof error.message === "string") return error.message;
-	if (error && typeof error === "object") try {
-		return JSON.stringify(error);
-	} catch (_e) {
-		return "Unknown error object";
-	}
-	return String(error);
-}
-function extractAxiosErrorContext(error) {
-	if (!isAxiosError(error)) return null;
-	return {
-		status: error.response?.status,
-		statusText: error.response?.statusText,
-		data: error.response?.data,
-		method: error.config?.method,
-		url: error.config?.url
-	};
-}
 function mapHevyErrorMessageByStatus(status) {
 	if (status === 401 || status === 403) return "The Hevy API key is invalid or has expired. Check HEVY_API_KEY.";
 	if (status === 404) return "The requested resource was not found in Hevy.";
@@ -658,15 +815,6 @@ function mapHevyErrorMessageByStatus(status) {
 	if (status && status >= 500 && status <= 599) return "Hevy API experienced an error. Please retry later.";
 	return null;
 }
-function stringifyErrorData(data) {
-	if (typeof data === "string") return data;
-	if (data && typeof data === "object") try {
-		return JSON.stringify(data);
-	} catch (_e) {
-		return "Unable to serialize error response data";
-	}
-	return String(data);
-}
 /**
 * Wrap an async function with standardized error handling
 *
@@ -678,209 +826,22 @@ function stringifyErrorData(data) {
 * @param context - Context information for error messages
 * @returns A function that catches errors and returns standardized error responses
 */
-function withErrorHandling(fn, context) {
+function withErrorHandling(fn, context, onError) {
 	return async (rawArgs) => {
 		const args = rawArgs ?? {};
 		try {
 			return await fn(args);
 		} catch (error) {
-			Sentry.withScope((scope) => {
-				scope.setTag("mcp.tool.context", context);
-				scope.setContext("mcpTool", {
-					context,
-					argumentKeyCount: Object.keys(args).length
-				});
-				Sentry.captureException(error);
-			});
-			return createErrorResponse(error, context);
-		}
-	};
-}
-//#endregion
-//#region src/utils/debug.ts
-const DEBUG_PREFIX = "[hevy-mcp:debug] ";
-const MAX_DEBUG_RECORD_LENGTH = 8192;
-const MAX_REDACTION_DEPTH = 4;
-const MAX_OBJECT_KEYS = 20;
-function isDebugEnabled(env = process.env) {
-	return env.HEVY_MCP_DEBUG === "1";
-}
-function redactValue(value, depth, seen) {
-	if (value === null) return "[null]";
-	if (typeof value !== "object") return `[${typeof value}]`;
-	if (seen.has(value)) return "[circular]";
-	if (Array.isArray(value)) {
-		const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
-		const length = lengthDescriptor && "value" in lengthDescriptor && typeof lengthDescriptor.value === "number" ? lengthDescriptor.value : 0;
-		if (depth >= MAX_REDACTION_DEPTH) return {
-			type: "array",
-			length,
-			items: "[max-depth]"
-		};
-		seen.add(value);
-		try {
-			const itemCount = Math.min(length, MAX_OBJECT_KEYS);
-			const items = {};
-			for (let index = 0; index < itemCount; index += 1) {
-				const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
-				items[`item-${index + 1}`] = descriptor && "value" in descriptor ? redactValue(descriptor.value, depth + 1, seen) : "[empty-or-accessor]";
-			}
-			return {
-				type: "array",
-				length,
-				items,
-				...length > MAX_OBJECT_KEYS ? { truncatedItems: length - MAX_OBJECT_KEYS } : {}
-			};
-		} finally {
-			seen.delete(value);
-		}
-	}
-	const keys = Object.keys(value);
-	if (depth >= MAX_REDACTION_DEPTH) return {
-		type: "object",
-		fieldCount: keys.length,
-		fields: "[max-depth]"
-	};
-	seen.add(value);
-	try {
-		const fields = {};
-		for (const [index, rawKey] of keys.slice(0, MAX_OBJECT_KEYS).entries()) {
-			const descriptor = Object.getOwnPropertyDescriptor(value, rawKey);
-			fields[`field-${index + 1}`] = descriptor && "value" in descriptor ? redactValue(descriptor.value, depth + 1, seen) : "[accessor]";
-		}
-		return {
-			type: "object",
-			fieldCount: keys.length,
-			fields,
-			...keys.length > MAX_OBJECT_KEYS ? { truncatedFields: keys.length - MAX_OBJECT_KEYS } : {}
-		};
-	} finally {
-		seen.delete(value);
-	}
-}
-/** Redact every input scalar while preserving bounded argument structure. */
-function redactToolArgs(args) {
-	try {
-		return redactValue(args, 0, /* @__PURE__ */ new WeakSet());
-	} catch {
-		return "[unavailable]";
-	}
-}
-/**
-* Write a single bounded structured debug record to stderr without throwing.
-*/
-function debugLog(event, data) {
-	if (!isDebugEnabled()) return;
-	try {
-		const record = JSON.stringify({
-			event,
-			...data
-		});
-		const output = record.length <= MAX_DEBUG_RECORD_LENGTH ? record : JSON.stringify({
-			event,
-			truncated: true
-		});
-		process.stderr.write(`${DEBUG_PREFIX}${output}\n`);
-	} catch {}
-}
-//#endregion
-//#region src/utils/telemetry-wrapper.ts
-/** Whitelist of safe argument keys that can be logged without exposing PII. */
-const ARGUMENT_WHITELIST = /* @__PURE__ */ new Set([
-	"page",
-	"pageSize",
-	"since",
-	"workoutId",
-	"routineId",
-	"folderId",
-	"exerciseTemplateId",
-	"date",
-	"startDate",
-	"endDate",
-	"updatedSince",
-	"includeCustom",
-	"limit",
-	"offset",
-	"refresh",
-	"query",
-	"primaryMuscleGroup"
-]);
-function extractSafeArgs(args) {
-	const attributes = {};
-	for (const [key, value] of Object.entries(args)) {
-		if (!ARGUMENT_WHITELIST.has(key)) continue;
-		if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") continue;
-		attributes[`mcp.tool.args.${key}`] = key === "query" && typeof value === "string" && value.length > 100 ? `${value.slice(0, 100)}...` : value;
-	}
-	return attributes;
-}
-/**
-* Wrap an MCP tool handler with its existing OpenTelemetry span and metrics.
-*/
-function withTelemetry(fn, context) {
-	return async (rawArgs) => {
-		const args = rawArgs ?? {};
-		if (isDebugEnabled()) debugLog("tool_invocation", {
-			tool: context,
-			params: redactToolArgs(args)
-		});
-		const argumentKeyCount = Object.keys(args).length;
-		const startTime = Date.now();
-		let isError = false;
-		toolInvocations.add(1, { tool_name: context });
-		const userId = getCurrentUserId();
-		const safeArgs = extractSafeArgs(args);
-		const whitelistedKeys = Object.keys(safeArgs).map((key) => key.replace("mcp.tool.args.", ""));
-		return tracer.startActiveSpan(`mcp.tool.${context}`, { attributes: {
-			"mcp.tool.name": context,
-			"mcp.tool.args.key_count": argumentKeyCount,
-			"mcp.tool.args.keys": whitelistedKeys.join(","),
-			...userId ? { "user.id": userId } : {},
-			...safeArgs
-		} }, async (span) => {
 			try {
-				const result = await fn(args);
-				isError = Boolean(result.isError);
-				span.setStatus({ code: isError ? SpanStatusCode.ERROR : SpanStatusCode.OK });
-				span.setAttribute("mcp.tool.result.is_error", isError);
-				if (result.content) {
-					span.setAttribute("mcp.tool.result.content_count", result.content.length);
-					const textLength = result.content.reduce((sum, item) => sum + (item.text?.length ?? 0), 0);
-					span.setAttribute("mcp.tool.result.text_length", textLength);
-				}
-				return result;
-			} catch (error) {
-				isError = true;
-				span.setStatus({ code: SpanStatusCode.ERROR });
-				span.recordException(error);
-				const errorType = determineErrorType(error, error instanceof Error ? error.message : String(error));
-				span.setAttribute("error.type", errorType);
-				const rawCode = error instanceof Error && "code" in error ? error.code : void 0;
-				if (rawCode !== void 0 && rawCode !== null) span.setAttribute("error.code", String(rawCode));
-				toolErrors.add(1, {
-					tool_name: context,
-					error_type: errorType
-				});
-				throw error;
-			} finally {
-				toolDuration.record(Date.now() - startTime, {
-					tool_name: context,
-					is_error: String(isError)
-				});
-				span.end();
+				onError?.(error, context, Object.keys(args).length);
+			} catch {
+				console.error("MCP error observer failure", { category: "ObserverError" });
 			}
-		});
+			return createErrorResponse(error, context);
+		}
 	};
 }
 //#endregion
-//#region src/utils/observability-wrapper.ts
-/**
-* Wrap an MCP tool handler with telemetry inside error response handling.
-*/
-function withObservability(fn, context) {
-	return withErrorHandling(withTelemetry(fn, context), context);
-}
-//#endregion
 //#region src/generated/client/schemas/userInfoSchema.ts
 /**
 * Generated by Kubb (https://kubb.dev/).
@@ -1248,7 +1209,7 @@ function buildMeasurementPayload(args) {
 	}
 	return payload;
 }
-function registerBodyMeasurementTools(server, hevyClient) {
+function registerBodyMeasurementTools(server, hevyClient, wrapHandler = withErrorHandling) {
 	const getBodyMeasurementsSchema = {
 		page: z.coerce.number().int().gte(1).default(1),
 		pageSize: z.coerce.number().int().gte(1).lte(10).default(10)
@@ -1267,7 +1228,7 @@ function registerBodyMeasurementTools(server, hevyClient) {
 		inputSchema: getBodyMeasurementsSchema,
 		outputSchema: bodyMeasurementsOutputSchema,
 		annotations: readOnlyAnnotations("Get Body Measurements")
-	}, withObservability(async (args) => {
+	}, wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { page, pageSize } = args;
 		const measurements = (await client.getBodyMeasurements({
@@ -1292,7 +1253,7 @@ function registerBodyMeasurementTools(server, hevyClient) {
 		inputSchema: getBodyMeasurementSchema,
 		outputSchema: bodyMeasurementOutputSchema,
 		annotations: readOnlyAnnotations("Get Body Measurement")
-	}, withObservability(async (args) => {
+	}, wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { date } = args;
 		const data = await client.getBodyMeasurement(date);
@@ -1313,7 +1274,7 @@ function registerBodyMeasurementTools(server, hevyClient) {
 		],
 		useCase: "Use for a date without an entry; use update-body-measurement when that date already exists.",
 		importantNotes: "date must use YYYY-MM-DD and be unique. Null fields are omitted and cannot clear values; an existing date returns 409."
-	}), createBodyMeasurementSchema, createAnnotations("Create Body Measurement"), withObservability(async (args) => {
+	}), createBodyMeasurementSchema, createAnnotations("Create Body Measurement"), wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { date, ...fields } = args;
 		await client.createBodyMeasurement({
@@ -1335,7 +1296,7 @@ function registerBodyMeasurementTools(server, hevyClient) {
 		],
 		useCase: "Use to change fields on an existing date; use create-body-measurement for a new date.",
 		importantNotes: "date must use YYYY-MM-DD and already exist. Provide at least one numeric field; nulls are omitted and cannot clear stored values."
-	}), updateBodyMeasurementSchema, updateAnnotations("Update Body Measurement"), withObservability(async (args) => {
+	}), updateBodyMeasurementSchema, updateAnnotations("Update Body Measurement"), wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { date, ...fields } = args;
 		const payload = buildMeasurementPayload(fields);
@@ -1349,7 +1310,7 @@ function registerBodyMeasurementTools(server, hevyClient) {
 /**
 * Register all routine folder-related tools with the MCP server
 */
-function registerFolderTools(server, hevyClient) {
+function registerFolderTools(server, hevyClient, wrapHandler = withErrorHandling) {
 	const getRoutineFoldersSchema = {
 		page: z.coerce.number().int().gte(1).default(1),
 		pageSize: z.coerce.number().int().gte(1).lte(10).default(5)
@@ -1368,7 +1329,7 @@ function registerFolderTools(server, hevyClient) {
 		inputSchema: getRoutineFoldersSchema,
 		outputSchema: routineFoldersOutputSchema,
 		annotations: readOnlyAnnotations("Get Routine Folders")
-	}, withObservability(async (args) => {
+	}, wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { page, pageSize } = args;
 		const folders = (await client.getRoutineFolders({
@@ -1393,7 +1354,7 @@ function registerFolderTools(server, hevyClient) {
 		inputSchema: getRoutineFolderSchema,
 		outputSchema: routineFolderOutputSchema,
 		annotations: readOnlyAnnotations("Get Routine Folder")
-	}, withObservability(async (args) => {
+	}, wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { folderId } = args;
 		const data = await client.getRoutineFolder(folderId);
@@ -1411,7 +1372,7 @@ function registerFolderTools(server, hevyClient) {
 		],
 		useCase: "Use to create an organizational destination before assigning new routines to a folderId.",
 		importantNotes: "Requires a non-empty name. Retrying or reusing a name can create duplicate folders."
-	}), createRoutineFolderSchema, createAnnotations("Create Routine Folder"), withObservability(async (args) => {
+	}), createRoutineFolderSchema, createAnnotations("Create Routine Folder"), wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { name } = args;
 		const data = await client.createRoutineFolder({ routine_folder: { title: name } });
@@ -1470,7 +1431,7 @@ const repRangeDisplayWarningText = "Note: Hevy's public API stores rep ranges (r
 /**
 * Register all routine-related tools with the MCP server
 */
-function registerRoutineTools(server, hevyClient) {
+function registerRoutineTools(server, hevyClient, wrapHandler = withErrorHandling) {
 	const getRoutinesSchema = {
 		page: z.coerce.number().int().gte(1).default(1),
 		pageSize: z.coerce.number().int().gte(1).lte(10).default(5)
@@ -1489,7 +1450,7 @@ function registerRoutineTools(server, hevyClient) {
 		inputSchema: getRoutinesSchema,
 		outputSchema: routinesOutputSchema,
 		annotations: readOnlyAnnotations("Get Routines")
-	}, withObservability(async (args) => {
+	}, wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { page, pageSize } = args;
 		const routines = (await client.getRoutines({
@@ -1514,7 +1475,7 @@ function registerRoutineTools(server, hevyClient) {
 		inputSchema: getRoutineSchema,
 		outputSchema: routineOutputSchema,
 		annotations: readOnlyAnnotations("Get Routine")
-	}, withObservability(async (args) => {
+	}, wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { routineId } = args;
 		const data = await client.getRoutineById(String(routineId));
@@ -1554,7 +1515,7 @@ function registerRoutineTools(server, hevyClient) {
 		],
 		useCase: "Use to create a reusable plan; use create-workout to log a completed session.",
 		importantNotes: "Requires exercise template IDs; folderId is optional. Retrying can create duplicates, and non-fixed rep ranges may not display in Hevy apps."
-	}), createRoutineSchema, createAnnotations("Create Routine"), withObservability(async (args) => {
+	}), createRoutineSchema, createAnnotations("Create Routine"), wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { title, folderId, notes, exercises } = args;
 		let usesRepRanges = false;
@@ -1630,7 +1591,7 @@ function registerRoutineTools(server, hevyClient) {
 		],
 		useCase: "Use to change a known routine; use create-routine for a separate new plan.",
 		importantNotes: "Requires routineId and the complete title and exercises payload; omitted exercises are removed. Non-fixed rep ranges may not display in Hevy apps."
-	}), updateRoutineSchema, updateAnnotations("Update Routine"), withObservability(async (args) => {
+	}), updateRoutineSchema, updateAnnotations("Update Routine"), wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { routineId, title, notes, exercises } = args;
 		let usesRepRanges = false;
@@ -1680,7 +1641,7 @@ function registerRoutineTools(server, hevyClient) {
 * Register all exercise template-related tools with the MCP server
 */
 function registerTemplateTools(server, hevyClient, options = {}) {
-	const { logger } = options;
+	const { catalog = createExerciseTemplateCatalog(), logger, wrapHandler = withErrorHandling } = options;
 	const getExerciseTemplatesSchema = {
 		page: z.coerce.number().int().gte(1).default(1),
 		pageSize: z.coerce.number().int().gte(1).lte(100).default(5)
@@ -1699,7 +1660,7 @@ function registerTemplateTools(server, hevyClient, options = {}) {
 		inputSchema: getExerciseTemplatesSchema,
 		outputSchema: exerciseTemplatesOutputSchema,
 		annotations: readOnlyAnnotations("Get Exercise Templates")
-	}, withObservability(async (args) => {
+	}, wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { page, pageSize } = args;
 		const templates = (await client.getExerciseTemplates({
@@ -1724,7 +1685,7 @@ function registerTemplateTools(server, hevyClient, options = {}) {
 		inputSchema: getExerciseTemplateSchema,
 		outputSchema: exerciseTemplateOutputSchema,
 		annotations: readOnlyAnnotations("Get Exercise Template")
-	}, withObservability(async (args) => {
+	}, wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { exerciseTemplateId } = args;
 		const data = await client.getExerciseTemplate(exerciseTemplateId);
@@ -1751,7 +1712,7 @@ function registerTemplateTools(server, hevyClient, options = {}) {
 		inputSchema: getExerciseHistorySchema,
 		outputSchema: exerciseHistoryOutputSchema,
 		annotations: readOnlyAnnotations("Get Exercise History")
-	}, withObservability(async (args) => {
+	}, wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { exerciseTemplateId, startDate, endDate } = args;
 		const history = (await client.getExerciseHistory(exerciseTemplateId, {
@@ -1777,7 +1738,7 @@ function registerTemplateTools(server, hevyClient, options = {}) {
 		],
 		useCase: "Use only when the needed movement is absent; search-exercise-templates should check existing templates first.",
 		importantNotes: "Requires title, exercise type, equipment category, and primary muscle group. Retrying or reusing a title can create duplicates."
-	}), createExerciseTemplateSchema, createAnnotations("Create Exercise Template"), withObservability(async (args) => {
+	}), createExerciseTemplateSchema, createAnnotations("Create Exercise Template"), wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { title, exerciseType, equipmentCategory, muscleGroup, otherMuscles } = args;
 		return createJsonResponse({
@@ -1810,10 +1771,10 @@ function registerTemplateTools(server, hevyClient, options = {}) {
 		inputSchema: searchExerciseTemplatesSchema,
 		outputSchema: exerciseTemplatesOutputSchema,
 		annotations: readOnlyAnnotations("Search Exercise Templates")
-	}, withObservability(async (args) => {
+	}, wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { query, primaryMuscleGroup, refresh } = args;
-		const catalog = await getExerciseTemplateCatalog(client, {
+		const templates = await catalog.get(client, {
 			refresh,
 			onRefreshed: (refreshedCatalog, reason) => {
 				try {
@@ -1827,12 +1788,12 @@ function registerTemplateTools(server, hevyClient, options = {}) {
 						}
 					});
 				} catch (error) {
-					console.error("Failed to emit structured exercise template cache log", error);
+					console.error("Failed to emit structured exercise template cache log", createSafeErrorDiagnostic(error));
 				}
 			}
 		});
 		const queryLower = query.toLowerCase();
-		let results = catalog.filter((t) => (t.title ?? "").toLowerCase().includes(queryLower));
+		let results = templates.filter((t) => (t.title ?? "").toLowerCase().includes(queryLower));
 		if (primaryMuscleGroup !== void 0) results = results.filter((t) => t.primary_muscle_group === primaryMuscleGroup);
 		if (results.length === 0) return createStructuredEmptyResponse(`No exercise templates found matching "${query}"${primaryMuscleGroup ? ` with primary muscle group "${primaryMuscleGroup}"` : ""}`, { exerciseTemplates: [] });
 		const exerciseTemplates = results.map(formatExerciseTemplate);
@@ -1841,7 +1802,7 @@ function registerTemplateTools(server, hevyClient, options = {}) {
 }
 //#endregion
 //#region src/tools/user.ts
-function registerUserTools(server, hevyClient) {
+function registerUserTools(server, hevyClient, wrapHandler = withErrorHandling) {
 	server.registerTool("get-user-info", {
 		description: describeTool({
 			summary: "Read-only. Returns the authenticated account's user ID, display name, and public profile URL.",
@@ -1856,7 +1817,7 @@ function registerUserTools(server, hevyClient) {
 		inputSchema: {},
 		outputSchema: userOutputSchema,
 		annotations: readOnlyAnnotations("Get User Info")
-	}, withObservability(async (_args) => {
+	}, wrapHandler(async (_args) => {
 		const data = await requireClient(hevyClient).getUserInfo();
 		if (!data?.data) return createStructuredEmptyResponse("No user info found for the authenticated user", { user: null });
 		return createStructuredJsonResponse(data.data, { user: data.data });
@@ -1879,7 +1840,7 @@ function formatWorkoutEvent(event) {
 /**
 * Register all workout-related tools with the MCP server
 */
-function registerWorkoutTools(server, hevyClient) {
+function registerWorkoutTools(server, hevyClient, wrapHandler = withErrorHandling) {
 	const getWorkoutsSchema = {
 		page: z.coerce.number().gte(1).default(1),
 		pageSize: z.coerce.number().int().gte(1).lte(10).default(5)
@@ -1898,7 +1859,7 @@ function registerWorkoutTools(server, hevyClient) {
 		inputSchema: getWorkoutsSchema,
 		outputSchema: workoutsOutputSchema,
 		annotations: readOnlyAnnotations("Get Workouts")
-	}, withObservability(async (args) => {
+	}, wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { page, pageSize } = args;
 		const workouts = (await client.getWorkouts({
@@ -1923,7 +1884,7 @@ function registerWorkoutTools(server, hevyClient) {
 		inputSchema: getWorkoutSchema,
 		outputSchema: workoutOutputSchema,
 		annotations: readOnlyAnnotations("Get Workout")
-	}, withObservability(async (args) => {
+	}, wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { workoutId } = args;
 		const data = await client.getWorkout(workoutId);
@@ -1945,7 +1906,7 @@ function registerWorkoutTools(server, hevyClient) {
 		inputSchema: {},
 		outputSchema: workoutCountOutputSchema,
 		annotations: readOnlyAnnotations("Get Workout Count")
-	}, withObservability(async () => {
+	}, wrapHandler(async () => {
 		const count = (await requireClient(hevyClient).getWorkoutCount())?.workout_count ?? 0;
 		return createStructuredJsonResponse({ count }, { count });
 	}, "get-workout-count"));
@@ -1968,7 +1929,7 @@ function registerWorkoutTools(server, hevyClient) {
 		inputSchema: getWorkoutEventsSchema,
 		outputSchema: workoutEventsOutputSchema,
 		annotations: readOnlyAnnotations("Get Workout Events")
-	}, withObservability(async (args) => {
+	}, wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { page, pageSize, since } = args;
 		const events = (await client.getWorkoutEvents({
@@ -2012,7 +1973,7 @@ function registerWorkoutTools(server, hevyClient) {
 		],
 		useCase: "Use to add a completed workout; use update-workout only when modifying an existing workout ID.",
 		importantNotes: "Requires UTC startTime/endTime in YYYY-MM-DDTHH:mm:ssZ form and exercise template IDs. Retrying can create duplicates."
-	}), createWorkoutSchema, createAnnotations("Create Workout"), withObservability(async (args) => {
+	}), createWorkoutSchema, createAnnotations("Create Workout"), wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { title, description, startTime, endTime, isPrivate, exercises } = args;
 		const requestBody = { workout: {
@@ -2077,7 +2038,7 @@ function registerWorkoutTools(server, hevyClient) {
 		],
 		useCase: "Use to revise a known workout; use create-workout for a new training session.",
 		importantNotes: "Requires workoutId plus the complete title, times, privacy, exercises, and sets payload; omitted optional values may be cleared or defaulted."
-	}), updateWorkoutSchema, updateAnnotations("Update Workout"), withObservability(async (args) => {
+	}), updateWorkoutSchema, updateAnnotations("Update Workout"), wrapHandler(async (args) => {
 		const client = requireClient(hevyClient);
 		const { workoutId, title, description, startTime, endTime, isPrivate, exercises } = args;
 		const requestBody = { workout: {
@@ -2110,131 +2071,24 @@ function registerWorkoutTools(server, hevyClient) {
 	}, "update-workout-operation"));
 }
 //#endregion
-//#region src/utils/config.ts
-const DEPRECATED_CLI_ARGUMENT_WARNING = [
-	"DEPRECATION WARNING: Passing the Hevy API key via CLI arguments",
-	"(--hevy-api-key=..., --hevyApiKey=..., hevy-api-key=...) is",
-	"deprecated and insecure. Use the HEVY_API_KEY environment",
-	"variable instead."
-].join(" ");
-/**
-* Parse CLI arguments and environment to derive configuration.
-* Priority order for API key: deprecated CLI flag forms > environment variable.
-* Supported deprecated CLI arg forms:
-*   --hevy-api-key=KEY
-*   --hevyApiKey=KEY
-*   hevy-api-key=KEY (bare, e.g. when passed after npm start -- )
-*/
-function parseConfig(argv, env) {
-	let apiKey = "";
-	let usedDeprecatedApiKeyArg = false;
-	const apiKeyArgPatterns = [
-		/^--hevy-api-key=(.+)$/i,
-		/^--hevyApiKey=(.+)$/i,
-		/^hevy-api-key=(.+)$/i
-	];
-	for (const raw of argv) {
-		for (const pattern of apiKeyArgPatterns) {
-			const m = raw.match(pattern);
-			if (m) {
-				apiKey = m[1];
-				usedDeprecatedApiKeyArg = true;
-				break;
-			}
-		}
-		if (apiKey) break;
-	}
-	if (usedDeprecatedApiKeyArg) console.error(DEPRECATED_CLI_ARGUMENT_WARNING);
-	if (!apiKey) apiKey = env.HEVY_API_KEY || "";
-	return { apiKey };
-}
-function assertApiKey(apiKey) {
-	if (!apiKey) {
-		console.error("Hevy API key is required. Provide it via the HEVY_API_KEY environment variable.");
-		process.exit(1);
-	}
-}
-//#endregion
-//#region src/utils/graceful-shutdown.ts
-const shutdownSignals = ["SIGINT", "SIGTERM"];
-const FORCED_EXIT_TIMEOUT_MS = 5e3;
-function flushStdout(stdout = process.stdout) {
-	return new Promise((resolve, reject) => {
-		try {
-			stdout.write("", (error) => {
-				if (error) {
-					reject(error);
-					return;
-				}
-				resolve();
-			});
-		} catch (error) {
-			reject(error);
-		}
-	});
-}
-function installGracefulShutdown({ target, process: processLike = process, logError = console.error, flush = flushStdout, forcedExitTimeoutMs = FORCED_EXIT_TIMEOUT_MS, scheduleForcedExit = setTimeout }) {
-	let listenersInstalled = true;
-	let shutdownSettled = false;
-	let shutdownPromise;
-	const cleanup = () => {
-		if (!listenersInstalled || shutdownPromise && !shutdownSettled) return;
-		listenersInstalled = false;
-		for (const signal of shutdownSignals) {
-			const listener = signalListeners.get(signal);
-			if (listener) processLike.removeListener(signal, listener);
-		}
-	};
-	const handleSignal = (signal) => {
-		if (shutdownPromise) return;
-		if (processLike.exitCode == null) processLike.exitCode = 0;
-		scheduleForcedExit(() => {
-			processLike.exit(processLike.exitCode ?? 0);
-		}, forcedExitTimeoutMs).unref();
-		shutdownPromise = (async () => {
-			logError(`Shutting down gracefully after ${signal}`);
-			let shutdownFailed = false;
-			let shutdownError;
-			try {
-				await target.close();
-			} catch (error) {
-				shutdownFailed = true;
-				shutdownError = error;
-			}
-			try {
-				await flush();
-			} catch (error) {
-				if (!shutdownFailed) shutdownError = error;
-				shutdownFailed = true;
-			}
-			try {
-				if (shutdownFailed) {
-					logError(`Graceful shutdown failed: ${shutdownError instanceof Error ? shutdownError.message : "Unknown shutdown error"}`);
-					processLike.exitCode = 1;
-					return;
-				}
-			} finally {
-				shutdownSettled = true;
-				cleanup();
-			}
-		})();
-	};
-	const signalListeners = new Map(shutdownSignals.map((signal) => [signal, () => handleSignal(signal)]));
-	for (const signal of shutdownSignals) {
-		const listener = signalListeners.get(signal);
-		if (listener) processLike.on(signal, listener);
-	}
-	return {
-		cleanup,
-		getShutdownPromise: () => shutdownPromise
-	};
+//#region src/tools/register.ts
+/** Register every Hevy tool in its production ordering. */
+function registerHevyTools(server, hevyClient, options = {}) {
+	const wrapHandler = options.wrapHandler ?? withErrorHandling;
+	registerWorkoutTools(server, hevyClient, wrapHandler);
+	registerRoutineTools(server, hevyClient, wrapHandler);
+	registerTemplateTools(server, hevyClient, {
+		catalog: options.catalog,
+		logger: options.logger,
+		wrapHandler
+	});
+	registerFolderTools(server, hevyClient, wrapHandler);
+	registerBodyMeasurementTools(server, hevyClient, wrapHandler);
+	registerUserTools(server, hevyClient, wrapHandler);
 }
 //#endregion
 //#region src/generated/.kubb/fetch.ts
-let _config = {
-	baseURL: typeof AXIOS_BASE !== "undefined" ? AXIOS_BASE : void 0,
-	headers: typeof AXIOS_HEADERS !== "undefined" ? JSON.parse(AXIOS_HEADERS) : void 0
-};
+let _config = {};
 const getConfig = () => _config;
 const setConfig = (config) => {
 	_config = config;
@@ -2246,17 +2100,37 @@ const mergeConfig = (...configs) => {
 			...merged,
 			...config,
 			headers: {
-				...merged.headers,
-				...config.headers
+				...Array.isArray(merged.headers) ? Object.fromEntries(merged.headers) : merged.headers,
+				...Array.isArray(config.headers) ? Object.fromEntries(config.headers) : config.headers
 			}
 		};
 	}, {});
 };
-const axiosInstance = axios.create(getConfig());
-const fetch$1 = async (config) => {
-	return axiosInstance.request(mergeConfig(getConfig(), config)).catch((e) => {
-		throw e;
+const fetch$1 = async (paramsConfig) => {
+	const normalizedParams = new URLSearchParams();
+	const config = mergeConfig(getConfig(), paramsConfig);
+	Object.entries(config.params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : value.toString());
+	});
+	let targetUrl = [config.baseURL, config.url].filter(Boolean).join("");
+	if (config.params) targetUrl += `?${normalizedParams}`;
+	const response = await globalThis.fetch(targetUrl, {
+		credentials: config.credentials || "same-origin",
+		method: config.method?.toUpperCase(),
+		body: config.data instanceof FormData ? config.data : JSON.stringify(config.data),
+		signal: config.signal,
+		headers: config.headers
 	});
+	return {
+		data: [
+			204,
+			205,
+			304
+		].includes(response.status) || !response.body ? {} : await response.json(),
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers
+	};
 };
 fetch$1.getConfig = getConfig;
 fetch$1.setConfig = setConfig;
@@ -2814,38 +2688,9 @@ async function putV1WorkoutsWorkoutid(workoutId, data, headers, config = {}) {
 }
 //#endregion
 //#region src/utils/hevyClientKubb.ts
-/**
-* Type-safe wrapper helper that enforces parameter types match the generated API.
-* This prevents arg-order regressions by using Parameters<> to extract expected types.
-*
-* Usage: wrapApi(api.postV1ExerciseTemplates)(data, headers, { client })
-* TypeScript will error if arguments don't match the generated signature.
-*/
-function wrapApi(fn) {
-	return fn;
-}
 const DEFAULT_API_TIMEOUT_MS = 3e4;
 const RETRY_BACKOFF_MAX_MS = 5e3;
-const HEVY_RETRY_EXHAUSTED_ERROR_CODE = "HEVY_RETRY_EXHAUSTED";
-const RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([
-	408,
-	429,
-	500,
-	502,
-	503,
-	504
-]);
-const RETRYABLE_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
-	"ECONNABORTED",
-	"ECONNREFUSED",
-	"ECONNRESET",
-	"EAI_AGAIN",
-	"ENETUNREACH",
-	"ENOTFOUND",
-	"ERR_NETWORK",
-	"ERR_SOCKET_TIMEOUT",
-	"ETIMEDOUT"
-]);
+const RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429]);
 const SAFE_STATIC_ENDPOINTS = /* @__PURE__ */ new Set([
 	"/v1/body_measurements",
 	"/v1/exercise_templates",
@@ -2864,86 +2709,21 @@ const SAFE_DYNAMIC_ENDPOINTS = [
 	["/v1/routines/", "/v1/routines/:routineId"],
 	["/v1/workouts/", "/v1/workouts/:workoutId"]
 ];
-function getApiTimeoutMs() {
-	const rawValue = process.env.HEVY_MCP_API_TIMEOUT;
-	if (!rawValue) return DEFAULT_API_TIMEOUT_MS;
-	const parsed = Number(rawValue);
-	if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_API_TIMEOUT_MS;
-	return Math.trunc(parsed);
-}
-function normalizeMaxGetRetries(value) {
-	if (value === void 0 || !Number.isFinite(value) || value < 0) return 3;
-	return Math.floor(value);
-}
-function normalizeTimeoutMs(value) {
-	if (value === void 0 || !Number.isFinite(value) || value <= 0) return getApiTimeoutMs();
-	const normalizedValue = Math.floor(value);
-	return normalizedValue > 0 ? normalizedValue : getApiTimeoutMs();
-}
-function sleep(ms) {
-	return new Promise((resolve) => {
-		setTimeout(resolve, ms);
-	});
-}
-function isGetRequest(config) {
-	return config.method?.toUpperCase() === "GET";
-}
-function isRetryableStatus(status) {
-	if (status === void 0) return false;
-	return RETRYABLE_STATUS_CODES.has(status);
-}
-function isTransientNetworkError(error) {
-	if (error.code === "ERR_CANCELED") return false;
-	if (error.code && RETRYABLE_NETWORK_ERROR_CODES.has(error.code)) return true;
-	if (error.response) return false;
-	const message = error.message.toLowerCase();
-	return message.includes("network") || message.includes("socket hang up") || message.includes("timeout");
-}
-function normalizeHeaderValue(value) {
-	if (typeof value === "string") {
-		const trimmed = value.trim();
-		return trimmed.length > 0 ? trimmed : void 0;
-	}
-	if (typeof value === "number" && Number.isFinite(value)) return String(value);
-	if (Array.isArray(value) && value.length > 0) return normalizeHeaderValue(value[0]);
-}
-function getHeaderValue(headers, key) {
-	if (!headers || typeof headers !== "object") return;
-	if ("get" in headers && typeof headers.get === "function") return normalizeHeaderValue(headers.get(key));
-	const headerRecord = headers;
-	return normalizeHeaderValue(headerRecord[key] ?? headerRecord[key.toLowerCase()] ?? headerRecord[key.toUpperCase()]);
-}
-function parseRetryAfterMs(value) {
-	const numericSeconds = Number(value);
-	if (Number.isFinite(numericSeconds) && numericSeconds >= 0) return Math.min(RETRY_BACKOFF_MAX_MS, Math.round(numericSeconds * 1e3));
-	const dateMillis = Date.parse(value);
-	if (Number.isNaN(dateMillis)) return;
-	return Math.min(RETRY_BACKOFF_MAX_MS, Math.max(0, dateMillis - Date.now()));
-}
-function getRetryAfterDelayMs(error) {
-	if (error.response?.status !== 429) return;
-	const retryAfterHeader = getHeaderValue(error.response.headers, "retry-after");
-	if (!retryAfterHeader) return;
-	return parseRetryAfterMs(retryAfterHeader);
+function wrapApi(fn) {
+	return fn;
 }
-function getExponentialBackoffMs(retryAttempt) {
-	const delay = 300 * 2 ** Math.max(0, retryAttempt - 1);
-	return Math.min(RETRY_BACKOFF_MAX_MS, delay);
+function normalizePositiveInteger(value, fallback) {
+	return value === void 0 || !Number.isFinite(value) || value <= 0 ? fallback : Math.max(1, Math.floor(value));
 }
-function getRetryDelayMs(error, retryAttempt) {
-	const exponentialDelay = getExponentialBackoffMs(retryAttempt);
-	const retryAfterDelay = getRetryAfterDelayMs(error);
-	if (retryAfterDelay === void 0) return exponentialDelay;
-	return Math.min(RETRY_BACKOFF_MAX_MS, Math.max(exponentialDelay, retryAfterDelay));
+function normalizeMaxGetRetries(value) {
+	return value === void 0 || !Number.isFinite(value) || value < 0 ? 3 : Math.floor(value);
 }
-function shouldRetryRequest(config, error) {
-	if (!isGetRequest(config)) return false;
-	return isRetryableStatus(error.response?.status) || isTransientNetworkError(error);
+function defaultSleep(milliseconds) {
+	return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 function getRequestContext(config) {
 	const method = (config.method ?? "GET").toUpperCase();
-	const url = config.url ?? "";
-	const rawEndpoint = url.split("?")[0] ?? url;
+	const rawEndpoint = (config.url ?? "").split("?")[0] ?? "";
 	let endpoint = "unknown";
 	if (SAFE_STATIC_ENDPOINTS.has(rawEndpoint)) endpoint = rawEndpoint;
 	else endpoint = SAFE_DYNAMIC_ENDPOINTS.find(([prefix]) => rawEndpoint.startsWith(prefix))?.[1] ?? "unknown";
@@ -2955,206 +2735,180 @@ function getRequestContext(config) {
 function emitClientLog(logger, message) {
 	try {
 		logger?.(message);
-	} catch (error) {
-		console.error("Failed to emit structured Hevy API log", error);
+	} catch {
+		console.error("Failed to emit structured Hevy API log");
 	}
 }
-function markRetryExhausted(error, retryCount) {
-	const retryError = error;
-	retryError.hevyRetryExhausted = true;
-	retryError.hevyRetryCount = retryCount;
-	retryError.hevyRetryStatus = error.response?.status;
-	if (retryError.code) retryError.hevyRetryOriginalCode = retryError.code;
-	retryError.code = HEVY_RETRY_EXHAUSTED_ERROR_CODE;
-}
-async function requestWithRetries(axiosInstance, config, maxGetRetries, logger) {
-	let retryCount = 0;
-	while (true) try {
-		return await axiosInstance.request(config);
-	} catch (error) {
-		if (!isAxiosError(error)) throw error;
-		const normalizedConfig = config;
-		const { method, endpoint } = getRequestContext(normalizedConfig);
-		const status = error.response?.status ?? null;
-		if (!shouldRetryRequest(normalizedConfig, error)) {
-			emitClientLog(logger, {
-				level: "error",
-				logger: "hevy-api",
-				data: {
-					message: "Hevy API request failed without retry",
-					status,
-					method,
-					endpoint
-				}
+function parseRetryAfterMs(value) {
+	if (!value) return void 0;
+	const seconds = Number(value);
+	if (Number.isFinite(seconds) && seconds >= 0) return Math.min(RETRY_BACKOFF_MAX_MS, Math.round(seconds * 1e3));
+	const dateMillis = Date.parse(value);
+	return Number.isNaN(dateMillis) ? void 0 : Math.min(RETRY_BACKOFF_MAX_MS, Math.max(0, dateMillis - Date.now()));
+}
+function getRetryDelayMs(error, retryAttempt) {
+	const exponential = Math.min(RETRY_BACKOFF_MAX_MS, 300 * 2 ** Math.max(0, retryAttempt - 1));
+	const retryAfter = error.status === 429 ? parseRetryAfterMs(error.headers?.get("retry-after") ?? null) : void 0;
+	return retryAfter === void 0 ? exponential : Math.min(RETRY_BACKOFF_MAX_MS, Math.max(exponential, retryAfter));
+}
+function buildUrl(baseUrl, config) {
+	if (!config.url?.startsWith("/v1/")) throw new HevyHttpError("Invalid Hevy API endpoint", {
+		method: config.method ?? "GET",
+		endpoint: "unknown",
+		code: "HEVY_INVALID_ENDPOINT"
+	});
+	const url = new URL(config.url, baseUrl);
+	if (config.params && typeof config.params === "object") {
+		for (const [key, value] of Object.entries(config.params)) if (value !== void 0) url.searchParams.append(key, value === null ? "null" : String(value));
+	}
+	return url;
+}
+async function parseResponseData(response) {
+	if ([
+		204,
+		205,
+		304
+	].includes(response.status) || !response.body) return {};
+	const text = await response.text();
+	if (!text) return {};
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+function getNetworkCode(error) {
+	return error instanceof DOMException && error.name === "AbortError" ? "ETIMEDOUT" : "ERR_NETWORK";
+}
+function isRetryable(error) {
+	if (error.code === "HEVY_REQUEST_ABORTED") return false;
+	return error.status === void 0 || RETRYABLE_STATUS_CODES.has(error.status) || error.status >= 500 && error.status <= 599;
+}
+function createNativeClient(apiKey, baseUrl, options) {
+	const fetchImplementation = options.fetch ?? globalThis.fetch;
+	const maxGetRetries = normalizeMaxGetRetries(options.maxGetRetries);
+	const timeoutMs = normalizePositiveInteger(options.timeoutMs, DEFAULT_API_TIMEOUT_MS);
+	const sleep = options.sleep ?? defaultSleep;
+	let clientConfig = { baseURL: baseUrl };
+	const client = (async (config) => {
+		const normalized = {
+			...clientConfig,
+			...config
+		};
+		const { method, endpoint } = getRequestContext(normalized);
+		const url = buildUrl(baseUrl, normalized);
+		let retryCount = 0;
+		while (true) {
+			if (normalized.signal?.aborted) throw new HevyHttpError("Hevy API request was canceled", {
+				method,
+				endpoint,
+				code: HEVY_REQUEST_ABORTED_ERROR_CODE
 			});
-			throw error;
-		}
-		if (retryCount >= maxGetRetries) {
-			emitClientLog(logger, {
-				level: status === 429 ? "warning" : "error",
-				logger: "hevy-api",
-				data: {
-					message: "Hevy API request failed after retries",
-					status,
-					attempt: retryCount + 1,
-					maxAttempts: maxGetRetries + 1,
+			const startedAt = Date.now();
+			const controller = new AbortController();
+			const abortFromCaller = () => controller.abort();
+			normalized.signal?.addEventListener("abort", abortFromCaller, { once: true });
+			const timeout = setTimeout(() => controller.abort(), timeoutMs);
+			try {
+				const headers = new Headers({ "api-key": apiKey });
+				if (normalized.data !== void 0 && !(normalized.data instanceof FormData)) headers.set("content-type", "application/json");
+				const response = await fetchImplementation(url, {
+					method,
+					headers,
+					redirect: "manual",
+					body: normalized.data instanceof FormData ? normalized.data : normalized.data === void 0 ? void 0 : JSON.stringify(normalized.data),
+					signal: controller.signal
+				});
+				const data = await parseResponseData(response);
+				if (!response.ok) throw new HevyHttpError(`Hevy API request failed (HTTP ${response.status})`, {
+					status: response.status,
+					statusText: response.statusText,
+					data,
+					headers: response.headers,
 					method,
 					endpoint
+				});
+				options.onRequestComplete?.({
+					method,
+					endpoint,
+					status: response.status,
+					durationMs: Date.now() - startedAt
+				});
+				return {
+					data,
+					status: response.status,
+					statusText: response.statusText,
+					headers: response.headers
+				};
+			} catch (cause) {
+				const error = isHevyHttpError(cause) ? cause : new HevyHttpError(normalized.signal?.aborted ? "Hevy API request was canceled" : "Hevy API network request failed", {
+					method,
+					endpoint,
+					code: normalized.signal?.aborted ? HEVY_REQUEST_ABORTED_ERROR_CODE : getNetworkCode(cause),
+					cause
+				});
+				options.onRequestComplete?.({
+					method,
+					endpoint,
+					status: error.status ?? 0,
+					durationMs: Date.now() - startedAt,
+					error
+				});
+				if (!(method === "GET" && isRetryable(error))) {
+					emitClientLog(options.logger, {
+						level: "error",
+						logger: "hevy-api",
+						data: {
+							message: "Hevy API request failed",
+							status: error.status ?? null,
+							method,
+							endpoint
+						}
+					});
+					throw error;
 				}
-			});
-			markRetryExhausted(error, retryCount);
-			throw error;
-		}
-		retryCount += 1;
-		const retryDelayMs = getRetryDelayMs(error, retryCount);
-		const retryAfterMs = getRetryAfterDelayMs(error);
-		emitClientLog(logger, {
-			level: status === 429 ? "warning" : "debug",
-			logger: "hevy-api",
-			data: {
-				message: status === 429 ? "Hevy API rate limit; retrying request" : "Retrying Hevy API request",
-				status,
-				attempt: retryCount + 1,
-				maxAttempts: maxGetRetries + 1,
-				delayMs: retryDelayMs,
-				...status === 429 ? { retryAfterMs: retryAfterMs ?? null } : {},
-				method,
-				endpoint
+				if (retryCount >= maxGetRetries) {
+					error.hevyRetryExhausted = true;
+					error.hevyRetryCount = retryCount;
+					error.code = HEVY_RETRY_EXHAUSTED_ERROR_CODE;
+					throw error;
+				}
+				retryCount += 1;
+				const delayMs = getRetryDelayMs(error, retryCount);
+				emitClientLog(options.logger, {
+					level: error.status === 429 ? "warning" : "debug",
+					logger: "hevy-api",
+					data: {
+						message: "Retrying Hevy API request",
+						status: error.status ?? null,
+						attempt: retryCount + 1,
+						maxAttempts: maxGetRetries + 1,
+						delayMs,
+						method,
+						endpoint
+					}
+				});
+				await sleep(delayMs);
+			} finally {
+				clearTimeout(timeout);
+				normalized.signal?.removeEventListener("abort", abortFromCaller);
 			}
-		});
-		await sleep(retryDelayMs);
-	}
-}
-function createResilientClient(axiosInstance, maxGetRetries, logger) {
-	let clientConfig = { baseURL: axiosInstance.defaults.baseURL };
-	const resilientClient = (async (config) => {
-		return requestWithRetries(axiosInstance, config, maxGetRetries, logger);
+		}
 	});
-	resilientClient.getConfig = () => ({ ...clientConfig });
-	resilientClient.setConfig = (config) => {
+	client.getConfig = () => ({ ...clientConfig });
+	client.setConfig = (config) => {
 		clientConfig = {
 			...clientConfig,
-			...config
+			...config,
+			baseURL: baseUrl
 		};
-		if (config.baseURL !== void 0) axiosInstance.defaults.baseURL = config.baseURL;
-		return resilientClient.getConfig();
+		return client.getConfig();
 	};
-	return resilientClient;
-}
-/**
-* 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
-	});
+	return client;
 }
 function createClient$1(apiKey, baseUrl = "https://api.hevyapp.com", options = {}) {
-	const { logger } = options;
-	const maxGetRetries = normalizeMaxGetRetries(options.maxGetRetries);
-	const timeoutMs = normalizeTimeoutMs(options.timeoutMs);
-	const axiosInstance = axios.create({
-		baseURL: baseUrl,
-		timeout: timeoutMs,
-		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;
-		const userId = getCurrentUserId();
-		tracedConfig._span = tracer.startSpan(`hevy.api.${method}`, { attributes: {
-			"http.method": method,
-			"http.url": url,
-			"http.base_url": config.baseURL ?? "",
-			"hevy.api.endpoint": endpoint,
-			...userId ? { "user.id": userId } : {}
-		} });
-		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
-		});
-		const requestContext = getRequestContext(response.config);
-		debugLog("api_response", {
-			method: requestContext.method,
-			endpoint: requestContext.endpoint,
-			durationMs,
-			status: response.status
-		});
-		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
-		});
-		const requestContext = getRequestContext(error.config ?? {});
-		debugLog("api_response", {
-			method: requestContext.method,
-			endpoint: requestContext.endpoint,
-			durationMs,
-			status: error.response?.status ?? null
-		});
-		finalizeRequestTrace({
-			span: tracedConfig._span,
-			statusCode: error.response?.status ?? 0,
-			durationMs,
-			method,
-			endpoint,
-			error
-		});
-		throw error;
-	});
 	const headers = { "api-key": apiKey };
-	const client = createResilientClient(axiosInstance, maxGetRetries, logger);
+	const client = createNativeClient(apiKey, baseUrl, options);
 	return {
 		getWorkouts: (params) => wrapApi(getV1Workouts)(headers, params, { client }),
 		getWorkout: (workoutId) => wrapApi(getV1WorkoutsWorkoutid)(workoutId, headers, { client }),
@@ -3177,7 +2931,10 @@ function createClient$1(apiKey, baseUrl = "https://api.hevyapp.com", options = {
 		getBodyMeasurement: (date) => wrapApi(getV1BodyMeasurementsDate)(date, headers, { client }),
 		createBodyMeasurement: (data) => wrapApi(postV1BodyMeasurements)(data, headers, { client }),
 		updateBodyMeasurement: (date, data) => wrapApi(putV1BodyMeasurementsDate)(date, data, headers, { client }),
-		getUserInfo: () => wrapApi(getV1UserInfo)(headers, { client })
+		getUserInfo: (config = {}) => wrapApi(getV1UserInfo)(headers, {
+			...config,
+			client
+		})
 	};
 }
 //#endregion
@@ -3201,50 +2958,430 @@ function createMcpClientLogger(server) {
 				return;
 			}
 			server.sendLoggingMessage(message).catch((error) => {
-				console.error(SEND_FAILURE_MESSAGE, error);
+				console.error(SEND_FAILURE_MESSAGE, createSafeErrorDiagnostic(error));
 			});
 		} catch (error) {
-			console.error(SEND_FAILURE_MESSAGE, error);
+			console.error(SEND_FAILURE_MESSAGE, createSafeErrorDiagnostic(error));
 		}
 	};
 }
 //#endregion
-//#region src/utils/stdio-observability.ts
-const UTF8_BOM = "";
-/** Maximum escaped characters included in a malformed stdin shape preview. */
-const STDIN_PARSE_SHAPE_PREVIEW_MAX_LENGTH = 200;
-const REDACTED_CONTENT_MARKER = "[REDACTED]";
-/**
-* Adapter boundary around MCP SDK stdio internals.
-*
-* MCP SDK v1.29.0 exposes public message-level hooks but does not expose a
-* public raw-chunk hook on `StdioServerTransport`. To capture chunk metadata,
-* we currently rely on private internals (`_ondata`, `_readBuffer`, `_buffer`)
-* in this one place.
-*
-* If those internals change in a future SDK release, this adapter should fail
-* closed and preserve default transport behavior (no instrumentation patching).
-*/
-function createSdkPrivateStdioAdapter(transport) {
-	const mutableTransport = transport;
+//#region src/shared-server.ts
+function createToolCountingServer(server) {
+	let count = 0;
 	return {
-		wrapOnData(onChunk) {
-			const originalOnData = mutableTransport._ondata;
-			if (typeof originalOnData !== "function") return;
-			mutableTransport._ondata = (chunk) => {
-				onChunk(chunk);
-				originalOnData(chunk);
+		server: new Proxy(server, { get(target, property, receiver) {
+			if (property === "tool") return (...args) => {
+				const result = target.tool(...args);
+				count += 1;
+				return result;
 			};
-		},
-		installReadMessageHook(onReadLine) {
-			const readBuffer = mutableTransport._readBuffer;
-			if (!readBuffer || typeof readBuffer.readMessage !== "function") return false;
-			readBuffer.readMessage = () => {
-				const buffer = readBuffer._buffer;
-				if (!buffer) return null;
-				const index = buffer.indexOf("\n");
-				if (index === -1) return null;
-				const lineBuffer = buffer.subarray(0, index);
+			if (property === "registerTool") {
+				const registerTool = (name, config, callback) => {
+					const result = target.registerTool(name, config, callback);
+					count += 1;
+					return result;
+				};
+				return registerTool;
+			}
+			return Reflect.get(target, property, receiver);
+		} }),
+		getCount: () => count
+	};
+}
+/** Construct and register a complete MCP server without importing Node-only code. */
+function createSharedMcpServer(options) {
+	const baseServer = new McpServer({
+		name: SERVER_NAME,
+		version: SERVER_VERSION
+	}, {
+		capabilities: { logging: {} },
+		instructions: SERVER_INSTRUCTIONS
+	});
+	const server = options.wrapServer?.(baseServer) ?? baseServer;
+	const logger = createMcpClientLogger(server);
+	const hevyClient = options.hevyClient ?? createClient(options.apiKey, "https://api.hevyapp.com", {
+		...options.clientOptions,
+		logger
+	});
+	const wrapHandler = options.wrapHandler ?? withErrorHandling;
+	const catalog = createExerciseTemplateCatalog();
+	const counting = createToolCountingServer(server);
+	registerHevyTools(counting.server, hevyClient, {
+		catalog,
+		logger,
+		wrapHandler
+	});
+	options.onToolsRegistered?.(counting.getCount());
+	registerWorkoutPrompts(server);
+	registerHevyResources(server, hevyClient, catalog);
+	return server;
+}
+//#endregion
+//#region src/utils/config.ts
+function parseConfig(env) {
+	return { apiKey: env.HEVY_API_KEY || "" };
+}
+function assertApiKey(apiKey) {
+	if (!apiKey) {
+		console.error("Hevy API key is required. Provide it via the HEVY_API_KEY environment variable.");
+		process.exit(1);
+	}
+}
+//#endregion
+//#region src/utils/graceful-shutdown.ts
+const shutdownSignals = ["SIGINT", "SIGTERM"];
+const FORCED_EXIT_TIMEOUT_MS = 5e3;
+function flushStdout(stdout = process.stdout) {
+	return new Promise((resolve, reject) => {
+		try {
+			stdout.write("", (error) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+				resolve();
+			});
+		} catch (error) {
+			reject(error);
+		}
+	});
+}
+function installGracefulShutdown({ target, process: processLike = process, logError = console.error, flush = flushStdout, forcedExitTimeoutMs = FORCED_EXIT_TIMEOUT_MS, scheduleForcedExit = setTimeout }) {
+	let listenersInstalled = true;
+	let shutdownSettled = false;
+	let shutdownPromise;
+	const cleanup = () => {
+		if (!listenersInstalled || shutdownPromise && !shutdownSettled) return;
+		listenersInstalled = false;
+		for (const signal of shutdownSignals) {
+			const listener = signalListeners.get(signal);
+			if (listener) processLike.removeListener(signal, listener);
+		}
+	};
+	const handleSignal = (signal) => {
+		if (shutdownPromise) return;
+		if (processLike.exitCode == null) processLike.exitCode = 0;
+		scheduleForcedExit(() => {
+			processLike.exit(processLike.exitCode ?? 0);
+		}, forcedExitTimeoutMs).unref();
+		shutdownPromise = (async () => {
+			logError(`Shutting down gracefully after ${signal}`);
+			let shutdownFailed = false;
+			let shutdownError;
+			try {
+				await target.close();
+			} catch (error) {
+				shutdownFailed = true;
+				shutdownError = error;
+			}
+			try {
+				await flush();
+			} catch (error) {
+				if (!shutdownFailed) shutdownError = error;
+				shutdownFailed = true;
+			}
+			try {
+				if (shutdownFailed) {
+					logError(`Graceful shutdown failed: ${shutdownError instanceof Error ? shutdownError.message : "Unknown shutdown error"}`);
+					processLike.exitCode = 1;
+					return;
+				}
+			} finally {
+				shutdownSettled = true;
+				cleanup();
+			}
+		})();
+	};
+	const signalListeners = new Map(shutdownSignals.map((signal) => [signal, () => handleSignal(signal)]));
+	for (const signal of shutdownSignals) {
+		const listener = signalListeners.get(signal);
+		if (listener) processLike.on(signal, listener);
+	}
+	return {
+		cleanup,
+		getShutdownPromise: () => shutdownPromise
+	};
+}
+//#endregion
+//#region src/utils/debug.ts
+const DEBUG_PREFIX = "[hevy-mcp:debug] ";
+const MAX_DEBUG_RECORD_LENGTH = 8192;
+const MAX_REDACTION_DEPTH = 4;
+const MAX_OBJECT_KEYS = 20;
+function isDebugEnabled(env = process.env) {
+	return env.HEVY_MCP_DEBUG === "1";
+}
+function redactValue(value, depth, seen) {
+	if (value === null) return "[null]";
+	if (typeof value !== "object") return `[${typeof value}]`;
+	if (seen.has(value)) return "[circular]";
+	if (Array.isArray(value)) {
+		const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+		const length = lengthDescriptor && "value" in lengthDescriptor && typeof lengthDescriptor.value === "number" ? lengthDescriptor.value : 0;
+		if (depth >= MAX_REDACTION_DEPTH) return {
+			type: "array",
+			length,
+			items: "[max-depth]"
+		};
+		seen.add(value);
+		try {
+			const itemCount = Math.min(length, MAX_OBJECT_KEYS);
+			const items = {};
+			for (let index = 0; index < itemCount; index += 1) {
+				const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+				items[`item-${index + 1}`] = descriptor && "value" in descriptor ? redactValue(descriptor.value, depth + 1, seen) : "[empty-or-accessor]";
+			}
+			return {
+				type: "array",
+				length,
+				items,
+				...length > MAX_OBJECT_KEYS ? { truncatedItems: length - MAX_OBJECT_KEYS } : {}
+			};
+		} finally {
+			seen.delete(value);
+		}
+	}
+	const keys = Object.keys(value);
+	if (depth >= MAX_REDACTION_DEPTH) return {
+		type: "object",
+		fieldCount: keys.length,
+		fields: "[max-depth]"
+	};
+	seen.add(value);
+	try {
+		const fields = {};
+		for (const [index, rawKey] of keys.slice(0, MAX_OBJECT_KEYS).entries()) {
+			const descriptor = Object.getOwnPropertyDescriptor(value, rawKey);
+			fields[`field-${index + 1}`] = descriptor && "value" in descriptor ? redactValue(descriptor.value, depth + 1, seen) : "[accessor]";
+		}
+		return {
+			type: "object",
+			fieldCount: keys.length,
+			fields,
+			...keys.length > MAX_OBJECT_KEYS ? { truncatedFields: keys.length - MAX_OBJECT_KEYS } : {}
+		};
+	} finally {
+		seen.delete(value);
+	}
+}
+/** Redact every input scalar while preserving bounded argument structure. */
+function redactToolArgs(args) {
+	try {
+		return redactValue(args, 0, /* @__PURE__ */ new WeakSet());
+	} catch {
+		return "[unavailable]";
+	}
+}
+/**
+* Write a single bounded structured debug record to stderr without throwing.
+*/
+function debugLog(event, data) {
+	if (!isDebugEnabled()) return;
+	try {
+		const record = JSON.stringify({
+			event,
+			...data
+		});
+		const output = record.length <= MAX_DEBUG_RECORD_LENGTH ? record : JSON.stringify({
+			event,
+			truncated: true
+		});
+		process.stderr.write(`${DEBUG_PREFIX}${output}\n`);
+	} catch {}
+}
+//#endregion
+//#region src/utils/hevy-client-observability.ts
+/** Node-only adapter; the Worker graph never imports telemetry or metrics. */
+function createNodeHevyClientOptions() {
+	const rawTimeout = process.env.HEVY_MCP_API_TIMEOUT;
+	const parsedTimeout = rawTimeout ? Number(rawTimeout) : NaN;
+	const timeoutMs = Number.isFinite(parsedTimeout) && parsedTimeout > 0 ? Math.floor(parsedTimeout) : void 0;
+	return {
+		...timeoutMs ? { timeoutMs } : {},
+		onRequestComplete(observation) {
+			const span = tracer.startSpan(`hevy.api.${observation.method}`, { attributes: {
+				"http.method": observation.method,
+				"http.status_code": observation.status,
+				"hevy.api.endpoint": observation.endpoint,
+				...getCurrentUserId() ? { "user.id": getCurrentUserId() } : {}
+			} });
+			span.setStatus({ code: observation.error ? SpanStatusCode.ERROR : SpanStatusCode.OK });
+			if (observation.error) {
+				const diagnostic = createSafeErrorDiagnostic(observation.error);
+				span.addEvent("hevy.api.failure", {
+					"error.category": diagnostic.category,
+					...diagnostic.code ? { "error.code": diagnostic.code } : {}
+				});
+			}
+			span.end();
+			apiCalls.add(1, {
+				method: observation.method,
+				endpoint: observation.endpoint,
+				status_code: observation.status
+			});
+			apiDuration.record(observation.durationMs, {
+				method: observation.method,
+				endpoint: observation.endpoint
+			});
+			debugLog("api_response", {
+				method: observation.method,
+				endpoint: observation.endpoint,
+				durationMs: observation.durationMs,
+				status: observation.status || null
+			});
+		}
+	};
+}
+//#endregion
+//#region src/utils/telemetry-wrapper.ts
+/** Whitelist of safe argument keys that can be logged without exposing PII. */
+const ARGUMENT_WHITELIST = /* @__PURE__ */ new Set([
+	"page",
+	"pageSize",
+	"since",
+	"workoutId",
+	"routineId",
+	"folderId",
+	"exerciseTemplateId",
+	"date",
+	"startDate",
+	"endDate",
+	"updatedSince",
+	"includeCustom",
+	"limit",
+	"offset",
+	"refresh",
+	"query",
+	"primaryMuscleGroup"
+]);
+function extractSafeArgs(args) {
+	const attributes = {};
+	for (const [key, value] of Object.entries(args)) {
+		if (!ARGUMENT_WHITELIST.has(key)) continue;
+		if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") continue;
+		attributes[`mcp.tool.args.${key}`] = key === "query" && typeof value === "string" && value.length > 100 ? `${value.slice(0, 100)}...` : value;
+	}
+	return attributes;
+}
+/**
+* Wrap an MCP tool handler with its existing OpenTelemetry span and metrics.
+*/
+function withTelemetry(fn, context) {
+	return async (rawArgs) => {
+		const args = rawArgs ?? {};
+		if (isDebugEnabled()) debugLog("tool_invocation", {
+			tool: context,
+			params: redactToolArgs(args)
+		});
+		const argumentKeyCount = Object.keys(args).length;
+		const startTime = Date.now();
+		let isError = false;
+		toolInvocations.add(1, { tool_name: context });
+		const userId = getCurrentUserId();
+		const safeArgs = extractSafeArgs(args);
+		const whitelistedKeys = Object.keys(safeArgs).map((key) => key.replace("mcp.tool.args.", ""));
+		return tracer.startActiveSpan(`mcp.tool.${context}`, { attributes: {
+			"mcp.tool.name": context,
+			"mcp.tool.args.key_count": argumentKeyCount,
+			"mcp.tool.args.keys": whitelistedKeys.join(","),
+			...userId ? { "user.id": userId } : {},
+			...safeArgs
+		} }, async (span) => {
+			try {
+				const result = await fn(args);
+				isError = Boolean(result.isError);
+				span.setStatus({ code: isError ? SpanStatusCode.ERROR : SpanStatusCode.OK });
+				span.setAttribute("mcp.tool.result.is_error", isError);
+				if (result.content) {
+					span.setAttribute("mcp.tool.result.content_count", result.content.length);
+					const textLength = result.content.reduce((sum, item) => sum + (item.text?.length ?? 0), 0);
+					span.setAttribute("mcp.tool.result.text_length", textLength);
+				}
+				return result;
+			} catch (error) {
+				isError = true;
+				span.setStatus({ code: SpanStatusCode.ERROR });
+				const diagnostic = createSafeErrorDiagnostic(error);
+				span.addEvent("mcp.tool.failure", {
+					"error.category": diagnostic.category,
+					...diagnostic.code ? { "error.code": diagnostic.code } : {},
+					...diagnostic.status !== void 0 ? { "http.status_code": diagnostic.status } : {},
+					...diagnostic.method ? { "http.method": diagnostic.method } : {},
+					...diagnostic.endpoint ? { "hevy.api.endpoint": diagnostic.endpoint } : {}
+				});
+				const errorType = determineErrorType(error, `${diagnostic.category} occurred`);
+				span.setAttribute("error.type", errorType);
+				toolErrors.add(1, {
+					tool_name: context,
+					error_type: errorType
+				});
+				throw error;
+			} finally {
+				toolDuration.record(Date.now() - startTime, {
+					tool_name: context,
+					is_error: String(isError)
+				});
+				span.end();
+			}
+		});
+	};
+}
+//#endregion
+//#region src/utils/observability-wrapper.ts
+/**
+* Wrap an MCP tool handler with telemetry inside error response handling.
+*/
+function withObservability(fn, context) {
+	return withErrorHandling(withTelemetry(fn, context), context, (error, _toolContext, argumentKeyCount) => {
+		const diagnostic = createSafeErrorDiagnostic(error);
+		Sentry.withScope((scope) => {
+			scope.setTag("error.category", diagnostic.category);
+			if (diagnostic.code) scope.setTag("error.code", diagnostic.code);
+			if (diagnostic.status !== void 0) scope.setTag("http.status_code", String(diagnostic.status));
+			scope.setContext("mcpTool", { argumentKeyCount });
+			scope.setContext("safeError", { ...diagnostic });
+			Sentry.captureMessage("MCP tool failure", "error");
+		});
+	});
+}
+//#endregion
+//#region src/utils/stdio-observability.ts
+const UTF8_BOM = "";
+/** Maximum escaped characters included in a malformed stdin shape preview. */
+const STDIN_PARSE_SHAPE_PREVIEW_MAX_LENGTH = 200;
+const REDACTED_CONTENT_MARKER = "[REDACTED]";
+/**
+* Adapter boundary around MCP SDK stdio internals.
+*
+* MCP SDK v1.29.0 exposes public message-level hooks but does not expose a
+* public raw-chunk hook on `StdioServerTransport`. To capture chunk metadata,
+* we currently rely on private internals (`_ondata`, `_readBuffer`, `_buffer`)
+* in this one place.
+*
+* If those internals change in a future SDK release, this adapter should fail
+* closed and preserve default transport behavior (no instrumentation patching).
+*/
+function createSdkPrivateStdioAdapter(transport) {
+	const mutableTransport = transport;
+	return {
+		wrapOnData(onChunk) {
+			const originalOnData = mutableTransport._ondata;
+			if (typeof originalOnData !== "function") return;
+			mutableTransport._ondata = (chunk) => {
+				onChunk(chunk);
+				originalOnData(chunk);
+			};
+		},
+		installReadMessageHook(onReadLine) {
+			const readBuffer = mutableTransport._readBuffer;
+			if (!readBuffer || typeof readBuffer.readMessage !== "function") return false;
+			readBuffer.readMessage = () => {
+				const buffer = readBuffer._buffer;
+				if (!buffer) return null;
+				const index = buffer.indexOf("\n");
+				if (index === -1) return null;
+				const lineBuffer = buffer.subarray(0, index);
 				readBuffer._buffer = buffer.subarray(index + 1);
 				return onReadLine(lineBuffer.toString("utf8").replace(/\r$/, ""));
 			};
@@ -3343,10 +3480,11 @@ function deserializeMessageWithObservability(line, chunkSnapshot) {
 			if (message && typeof message === "object" && "method" in message) span.setAttribute("mcp.method", String(message.method));
 			return message;
 		} catch (error) {
+			const diagnostic = createSafeErrorDiagnostic(error);
 			const failurePosition = parseFailurePosition(error);
 			const failureLocation = getFailureLocation(failurePosition, lineHadLeadingBom);
 			span.setStatus({ code: SpanStatusCode.ERROR });
-			span.recordException(error);
+			span.addEvent("mcp.stdio.parse.failure", { "error.category": diagnostic.category });
 			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 });
@@ -3363,9 +3501,9 @@ function deserializeMessageWithObservability(line, chunkSnapshot) {
 					failureLocation,
 					failurePosition,
 					failureStage: "deserializeMessage",
-					errorName: error instanceof Error ? error.name : "UnknownError"
+					errorCategory: diagnostic.category
 				});
-				Sentry.captureException(error);
+				Sentry.captureMessage("MCP stdin parse failure", "error");
 			});
 			reportStdinParseFailure(error, line, lineByteLength, failureLocation, failurePosition);
 			throw error;
@@ -3520,34 +3658,6 @@ function scheduleUpdateCheck(options, overrides = {}) {
 //#region src/index.ts
 const name = name$1;
 const version = version$1;
-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."
-	].join(" "),
-	[
-		"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."
-	].join(" "),
-	[
-		"Workflow: search exercise templates first, then use the returned",
-		"template IDs when creating workouts or routines. To create a completed",
-		"workout from a routine, fetch the routine as a plan, then obtain the",
-		"actual completed sets and end time from the user; never invent completion",
-		"data. Use the built-in workflow prompts when they match the task."
-	].join(" "),
-	["Pagination: start at page 1 and fetch only the pages needed. Most list", "tools allow pageSize up to 10; get-exercise-templates allows up to 100."].join(" "),
-	[
-		"Rate limits and retries: minimize repeated calls. If Hevy returns HTTP",
-		"429, follow its retry guidance. Transient read requests retry",
-		"automatically, but write requests do not; confirm uncertain write",
-		"outcomes before trying again."
-	].join(" ")
-].join("\n\n");
 const HELP_TEXT = [
 	"Usage:",
 	"  hevy-mcp [options]",
@@ -3555,16 +3665,13 @@ const HELP_TEXT = [
 	"Options:",
 	"  -h, --help                 Show this help message and exit",
 	"  -v, --version              Show version and exit",
-	"  --hevy-api-key=<api-key>   (deprecated, use HEVY_API_KEY env var)",
 	"",
 	"Environment:",
 	"  HEVY_API_KEY=<api-key>     Hevy API key from Hevy app settings",
 	"  HEVY_MCP_DEBUG=1           Enable verbose diagnostics on stderr",
 	"",
 	"Examples:",
-	"  HEVY_API_KEY=your-key npx hevy-mcp",
-	"  npx hevy-mcp --hevy-api-key=your-key",
-	"  npm start -- --hevy-api-key=your-key"
+	"  HEVY_API_KEY=your-key npx hevy-mcp"
 ].join("\n");
 function getCliAction(args) {
 	for (const arg of args) {
@@ -3595,29 +3702,8 @@ 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 createToolCountingServer(server) {
-	let count = 0;
-	return {
-		server: new Proxy(server, { get(target, property, receiver) {
-			if (property === "tool") return (...args) => {
-				const registeredTool = target.tool(...args);
-				count += 1;
-				return registeredTool;
-			};
-			if (property === "registerTool") {
-				const registerTool = (name, config, callback) => {
-					const registeredTool = target.registerTool(name, config, callback);
-					count += 1;
-					return registeredTool;
-				};
-				return registerTool;
-			}
-			return Reflect.get(target, property, receiver);
-		} }),
-		getCount: () => count
-	};
-}
 function getHttpStatus(error) {
+	if (isHevyHttpError(error)) return error.status;
 	if (!error || typeof error !== "object" || !("response" in error)) return;
 	const response = error.response;
 	if (!response || typeof response !== "object" || !("status" in response)) return;
@@ -3655,45 +3741,14 @@ function buildServer(apiKey) {
 		try {
 			Sentry.setUser({ id: userId });
 			setCurrentUserId(userId);
-			const baseServer = new McpServer({
-				name,
-				version
-			}, {
-				capabilities: { logging: {} },
-				instructions: SERVER_INSTRUCTIONS
-			});
-			const server = Sentry.wrapMcpServerWithSentry(baseServer);
-			const clientLogger = createMcpClientLogger(server);
-			const hevyClient = tracer.startActiveSpan("mcp.hevy-client.initialize", (childSpan) => {
-				try {
-					return createClient(apiKey, HEVY_API_BASEURL, { logger: clientLogger });
-				} finally {
-					childSpan.end();
-				}
+			const server = createSharedMcpServer({
+				apiKey,
+				clientOptions: createNodeHevyClientOptions(),
+				wrapHandler: withObservability,
+				wrapServer: (baseServer) => Sentry.wrapMcpServerWithSentry(baseServer),
+				onToolsRegistered: (count) => span.setAttribute("mcp.tools.count", count)
 			});
 			console.error("Hevy client initialized with API key");
-			tracer.startActiveSpan("mcp.tools.register", (toolsSpan) => {
-				try {
-					const counting = createToolCountingServer(server);
-					registerWorkoutTools(counting.server, hevyClient);
-					registerRoutineTools(counting.server, hevyClient);
-					registerTemplateTools(counting.server, hevyClient, { logger: clientLogger });
-					registerFolderTools(counting.server, hevyClient);
-					registerBodyMeasurementTools(counting.server, hevyClient);
-					registerUserTools(counting.server, hevyClient);
-					toolsSpan.setAttribute("mcp.tools.count", counting.getCount());
-				} finally {
-					toolsSpan.end();
-				}
-			});
-			registerWorkoutPrompts(server);
-			tracer.startActiveSpan("mcp.resources.register", { attributes: { "mcp.resources.count": 4 } }, (resourcesSpan) => {
-				try {
-					registerHevyResources(server, hevyClient);
-				} finally {
-					resourcesSpan.end();
-				}
-			});
 			span.setStatus({ code: SpanStatusCode.OK });
 			return server;
 		} catch (e) {
@@ -3710,8 +3765,7 @@ async function createServer({ config }) {
 	return buildServer(apiKey);
 }
 async function runServer() {
-	const args = process.argv.slice(2);
-	const cliAction = getCliAction(args);
+	const cliAction = getCliAction(process.argv.slice(2));
 	if (cliAction === "version") {
 		console.error(`${name} v${version}`);
 		return;
@@ -3723,7 +3777,7 @@ async function runServer() {
 	serverStartups.add(1, { version });
 	await tracer.startActiveSpan("mcp.server.run", { attributes: { "mcp.transport": "stdio" } }, async (span) => {
 		try {
-			const apiKey = parseConfig(args, process.env).apiKey;
+			const apiKey = parseConfig(process.env).apiKey;
 			assertApiKey(apiKey);
 			const server = await createServer({ config: { apiKey } });
 			console.error("Starting MCP server in stdio mode");
@@ -3754,6 +3808,6 @@ async function runServer() {
 	});
 }
 //#endregion
-export { createServer as n, runServer as r, configSchema as t };
+export { createSafeErrorDiagnostic as i, createServer as n, runServer as r, configSchema as t };
 
-//# sourceMappingURL=src-c3mB-R0m.mjs.map
+//# sourceMappingURL=src-CkkrTrrg.mjs.map