hevy-mcp 3.1.1 → 3.2.1

package/dist/{src-CkkrTrrg.mjs → src-D1O3O9f2.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@3.1.1" };
+		e.SENTRY_RELEASE = { id: "hevy-mcp@3.2.1" };
 		var n = new e.Error().stack;
-		n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "c68eeb18-d351-49fe-9f67-3f26fa89bfdb", e._sentryDebugIdIdentifier = "sentry-dbid-c68eeb18-d351-49fe-9f67-3f26fa89bfdb");
+		n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "8ce801d0-ad38-40ee-a7f3-dc829e212db8", e._sentryDebugIdIdentifier = "sentry-dbid-8ce801d0-ad38-40ee-a7f3-dc829e212db8");
 	} catch (e) {}
 })();
 import * as Sentry from "@sentry/node";
@@ -40,10 +40,10 @@ import semver from "semver";
 * OTel Collector → Honeycomb: performance traces, metrics
 */
 const name$1 = "hevy-mcp";
-const version$1 = "3.1.1";
+const version$1 = "3.2.1";
 const collectorToken = "NH9vOela-HYreQxAbJa68cjEmORoEKM57EvneUDVcOo";
 const COLLECTOR_ENDPOINT = "https://otel.chrisdoc.dev/v1";
-const sentryRelease = process.env.SENTRY_RELEASE ?? `hevy-mcp@3.1.1`;
+const sentryRelease = process.env.SENTRY_RELEASE ?? `hevy-mcp@3.2.1`;
 const resource = resourceFromAttributes({
 	"service.name": name$1,
 	"service.version": version$1
@@ -127,8 +127,81 @@ const stdioParseErrors = meter.createCounter("mcp.stdio.parse_errors", { descrip
 /** Total server startup count, grouped by version. */
 const serverStartups = meter.createCounter("mcp.server.startups", { description: "Total server startup count" });
 //#endregion
+//#region src/utils/schemas.ts
+function coerceNullishNumberInput(value) {
+	if (value === null || value === void 0) return value;
+	if (typeof value !== "string") return value;
+	const trimmed = value.trim();
+	if (trimmed === "") return;
+	const lowered = trimmed.toLowerCase();
+	if (lowered === "null") return null;
+	if (lowered === "undefined") return;
+	const asNumber = Number(trimmed);
+	if (Number.isNaN(asNumber)) return value;
+	return asNumber;
+}
+const zNullableInt = z.preprocess(coerceNullishNumberInput, z.number().int().nullable().optional());
+const zNullableNumber = z.preprocess((value) => value === "" ? void 0 : value, z.coerce.number().nullable().optional());
+const zOptionalRepRange = z.preprocess((value) => value === null ? void 0 : value, z.object({
+	start: zNullableInt,
+	end: zNullableInt
+}).optional());
+const setTypeEnum = z.enum([
+	"warmup",
+	"normal",
+	"failure",
+	"dropset"
+]).default("normal");
+const muscleGroupEnum = z.enum([
+	"abdominals",
+	"shoulders",
+	"biceps",
+	"triceps",
+	"forearms",
+	"quadriceps",
+	"hamstrings",
+	"calves",
+	"glutes",
+	"abductors",
+	"adductors",
+	"lats",
+	"upper_back",
+	"traps",
+	"lower_back",
+	"chest",
+	"cardio",
+	"neck",
+	"full_body",
+	"other"
+]);
+const exerciseTypeEnum = z.enum([
+	"weight_reps",
+	"reps_only",
+	"bodyweight_reps",
+	"bodyweight_assisted_reps",
+	"duration",
+	"weight_duration",
+	"distance_duration",
+	"short_distance_weight"
+]);
+const equipmentCategoryEnum = z.enum([
+	"none",
+	"barbell",
+	"dumbbell",
+	"kettlebell",
+	"machine",
+	"plate",
+	"resistance_band",
+	"suspension",
+	"other"
+]);
+const UTC_TIMESTAMP_MESSAGE = "Must use the UTC format YYYY-MM-DDTHH:mm:ssZ";
+const utcSecondTimestamp = z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/, UTC_TIMESTAMP_MESSAGE).refine((value) => {
+	const parsed = new Date(value);
+	return !Number.isNaN(parsed.getTime()) && parsed.toISOString().replace(".000Z", "Z") === value;
+}, UTC_TIMESTAMP_MESSAGE);
+//#endregion
 //#region src/prompts/workouts.ts
-const utcSecondTimestamp = z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/, "Must use the UTC format YYYY-MM-DDTHH:mm:ssZ");
 /** Register guided workout workflow prompts. */
 function registerWorkoutPrompts(server) {
 	server.registerPrompt("analyze-workout-progress", {
@@ -141,9 +214,8 @@ function registerWorkoutPrompts(server) {
 			type: "text",
 			text: [
 				`Analyze my workout progress over the last ${weeks} weeks.`,
-				"Use get-workout-count to establish the available workout total.",
-				"Then call get-workouts with pageSize=10 and continue through pages until the requested date window is fully covered or no more workouts remain.",
-				"Also call get-body-measurements with pageSize=10 and paginate until the same date window is covered or no more measurements remain.",
+				"Call get-training-summary with the requested weeks; it combines recent workouts and body measurements into one compact evidence set.",
+				"Use the returned period, workout frequency, volume, exercise variety, session list, and measurement trend fields rather than issuing separate count and pagination calls.",
 				"Base the analysis on retrieved evidence and discuss workout frequency, training volume, exercise variety, consistency, and body-measurement trends.",
 				"Distinguish observations from suggestions, note missing or limited data, and do not make unsupported claims or medical conclusions."
 			].join("\n")
@@ -173,137 +245,31 @@ function registerWorkoutPrompts(server) {
 	}] }));
 }
 //#endregion
-//#region src/utils/cache.ts
-/**
-* Shared in-memory cache for async fetches with TTL, LRU eviction,
-* in-flight de-duplication, and explicit refresh/invalidation support.
-*/
-var AsyncTtlCache = class {
-	ttlMs;
-	maxSize;
-	now;
-	entries = /* @__PURE__ */ new Map();
-	inFlight = /* @__PURE__ */ new Map();
-	requestCounter = 0;
-	constructor(options, now = Date.now) {
-		const { ttlMs, maxSize } = options;
-		if (ttlMs <= 0) throw new Error("Cache ttlMs must be greater than 0.");
-		if (maxSize <= 0) throw new Error("Cache maxSize must be greater than 0.");
-		this.ttlMs = ttlMs;
-		this.maxSize = maxSize;
-		this.now = now;
-	}
-	async getOrFetch(key, fetcher, options = {}) {
-		const { refresh = false } = options;
-		if (refresh) this.invalidate(key);
-		else {
-			const cachedEntry = this.entries.get(key);
-			if (cachedEntry !== void 0) {
-				if (cachedEntry.expiresAt > this.now()) {
-					this.markAsRecentlyUsed(key, cachedEntry);
-					return cachedEntry.value;
-				}
-				this.entries.delete(key);
-			}
-			const inFlightEntry = this.inFlight.get(key);
-			if (inFlightEntry !== void 0) return inFlightEntry.promise;
-		}
-		const requestId = ++this.requestCounter;
-		const request = (async () => {
-			try {
-				const value = await fetcher();
-				if (this.isCurrentRequest(key, requestId)) this.setValue(key, value);
-				return value;
-			} finally {
-				if (this.inFlight.get(key)?.requestId === requestId) this.inFlight.delete(key);
-			}
-		})();
-		this.inFlight.set(key, {
-			promise: request,
-			requestId
-		});
-		return request;
-	}
-	invalidate(key) {
-		this.entries.delete(key);
-		this.inFlight.delete(key);
-	}
-	clear() {
-		this.entries.clear();
-		this.inFlight.clear();
-	}
-	get size() {
-		return this.entries.size;
-	}
-	isCurrentRequest(key, requestId) {
-		return this.inFlight.get(key)?.requestId === requestId;
-	}
-	markAsRecentlyUsed(key, entry) {
-		this.entries.delete(key);
-		this.entries.set(key, entry);
-	}
-	setValue(key, value) {
-		this.entries.delete(key);
-		this.entries.set(key, {
-			value,
-			expiresAt: this.now() + this.ttlMs
-		});
-		this.evictLeastRecentlyUsed();
-	}
-	evictLeastRecentlyUsed() {
-		while (this.entries.size > this.maxSize) {
-			const oldestKey = this.entries.keys().next().value;
-			if (oldestKey === void 0) return;
-			this.entries.delete(oldestKey);
-		}
-	}
-};
-//#endregion
-//#region src/utils/exercise-template-catalog.ts
-const EXERCISE_TEMPLATE_CATALOG_CACHE_KEY = "exercise-template-catalog";
-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;
-	return pageCount;
-}
-async function fetchExerciseTemplateCatalog(hevyClient) {
-	const allTemplates = [];
+//#region src/utils/pagination.ts
+async function fetchAllPages(loader, pageSize) {
+	const items = [];
 	let page = 1;
-	let pageCount = 1;
-	do {
-		const data = await hevyClient.getExerciseTemplates({
-			page,
-			pageSize: 100
-		});
-		allTemplates.push(...data?.exercise_templates ?? []);
-		pageCount = getSafePageCount$1(data, page);
-		page++;
-	} while (page <= pageCount);
-	return allTemplates;
-}
-/** 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();
-		}
-	};
+	while (true) {
+		const result = await loader(page, pageSize);
+		if (result.items.length === 0) return items;
+		items.push(...result.items);
+		const pageCount = result.pageCount;
+		if (typeof pageCount !== "number" || !Number.isSafeInteger(pageCount) || pageCount <= page) return items;
+		page += 1;
+	}
 }
 //#endregion
+//#region src/generated/client/schemas/userInfoSchema.ts
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+const userInfoSchema = z$1.object({
+	id: z$1.optional(z$1.string().describe("The user ID.")),
+	name: z$1.optional(z$1.string().describe("The user's display name.")),
+	url: z$1.optional(z$1.string().describe("The user's public profile URL."))
+});
+//#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";
@@ -334,7 +300,7 @@ function isHevyHttpError(error) {
 	return error instanceof HevyHttpError;
 }
 //#endregion
-//#region src/utils/safe-error-diagnostic.ts
+//#region src/utils/error-policy.ts
 const SAFE_ERROR_CODES = /* @__PURE__ */ new Set([
 	"EAI_AGAIN",
 	"ECONNABORTED",
@@ -385,6 +351,108 @@ const SAFE_SOURCE_SUFFIXES = [
 ];
 const PROJECT_PATH_MARKER = "/hevy-mcp/";
 const MAX_STACK_POSITION = 1e6;
+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) {
+	try {
+		if (!headers || typeof headers !== "object") return void 0;
+		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()]);
+	} catch {
+		return;
+	}
+}
+/** Extract a valid HTTP status without retaining untrusted error metadata. */
+function extractErrorStatus(error) {
+	try {
+		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;
+	} catch {
+		return;
+	}
+}
+/** Return whether the client exhausted its bounded transient retry policy. */
+function isRetryExhausted(error) {
+	try {
+		return !!error && typeof error === "object" && error.hevyRetryExhausted === true;
+	} catch {
+		return false;
+	}
+}
+/** Interpret a Retry-After header as seconds from the supplied current time. */
+function getRetryAfterSeconds(error, now = Date.now()) {
+	try {
+		if (!isHevyHttpError(error)) return void 0;
+		const retryAfterHeader = getHeaderValue(error.headers, "retry-after");
+		if (!retryAfterHeader) return void 0;
+		const seconds = Number(retryAfterHeader);
+		if (Number.isFinite(seconds) && seconds >= 0) return seconds;
+		const retryAtMillis = Date.parse(retryAfterHeader);
+		if (Number.isNaN(retryAtMillis)) return void 0;
+		return Math.ceil(Math.max(0, retryAtMillis - now) / 1e3);
+	} catch {
+		return;
+	}
+}
+/** Map bounded Hevy HTTP statuses to stable user-facing messages. */
+function getStatusErrorMessage(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.";
+	if (status === 409) return "A conflict occurred (e.g., a body measurement already exists for this date). Use the update tool instead.";
+	if (status === 422) return "The request failed Hevy validation. Check the field values and try again.";
+	if (status === 429) return "Rate limited by Hevy. Please wait and retry.";
+	if (status !== void 0 && status >= 500 && status <= 599) return "Hevy API experienced an error. Please retry later.";
+	return null;
+}
+function formatSecondsLabel(seconds) {
+	const roundedSeconds = Math.max(0, Math.round(seconds));
+	return `${roundedSeconds} second${roundedSeconds === 1 ? "" : "s"}`;
+}
+function getRateLimitMessage(error) {
+	const seconds = getRetryAfterSeconds(error);
+	if (seconds !== void 0) return `Rate limited by Hevy (HTTP 429). Please wait about ${formatSecondsLabel(seconds)} before retrying.`;
+	return "Rate limited by Hevy (HTTP 429). Please wait and retry your request.";
+}
+function getRetryExhaustedMessage(error) {
+	let retryCount;
+	try {
+		retryCount = typeof error === "object" && error !== null ? error.hevyRetryCount : void 0;
+	} catch {
+		retryCount = void 0;
+	}
+	const attemptCount = typeof retryCount === "number" && Number.isFinite(retryCount) ? retryCount + 1 : void 0;
+	if (attemptCount) return `Unable to complete the request after ${attemptCount} attempts to the Hevy API due to transient failures. Please try again shortly.`;
+	return "Unable to complete the request after multiple attempts to the Hevy API due to transient failures. Please try again shortly.";
+}
+/** Classify an error using bounded status, names, and supplied text. */
+function determineErrorType(error, message) {
+	if (isRetryExhausted(error)) return "NETWORK_ERROR";
+	if (extractErrorStatus(error) === 429) return "RATE_LIMIT";
+	let originalMessage = "";
+	let nameLower = "";
+	try {
+		if (error instanceof Error) {
+			originalMessage = error.message.slice(0, 512);
+			nameLower = error.name.toLowerCase();
+		}
+	} catch {
+		originalMessage = "";
+		nameLower = "";
+	}
+	const classificationText = `${message}\n${originalMessage}`.toLowerCase();
+	if (nameLower.includes("network") || classificationText.includes("network") || classificationText.includes("fetch") || classificationText.includes("timeout")) return "NETWORK_ERROR";
+	if (nameLower.includes("validation") || classificationText.includes("validation") || classificationText.includes("invalid") || classificationText.includes("required")) return "VALIDATION_ERROR";
+	if (classificationText.includes("not found") || classificationText.includes("404") || classificationText.includes("does not exist")) return "NOT_FOUND";
+	if (nameLower.includes("api") || classificationText.includes("api") || classificationText.includes("server error") || classificationText.includes("500")) return "API_ERROR";
+	return "UNKNOWN_ERROR";
+}
 function classifyError(error) {
 	if (isHevyHttpError(error)) return "HevyHttpError";
 	if (error instanceof TypeError) return "TypeError";
@@ -403,10 +471,6 @@ function getSafeCode(error) {
 	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();
@@ -419,7 +483,7 @@ function getSafeEndpoint(error) {
 function parseSafeStackFrames(error) {
 	if (!(error instanceof Error) || typeof error.stack !== "string") return;
 	const frames = [];
-	for (const frameLine of error.stack.split("\n").slice(1)) {
+	for (const frameLine of error.stack.split(/\r?\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;
@@ -439,11 +503,12 @@ function parseSafeStackFrames(error) {
 	}
 	return frames.length > 0 ? frames : void 0;
 }
+/** Build bounded diagnostic metadata with no raw messages, payloads, or URLs. */
 function createSafeErrorDiagnostic(error) {
 	try {
 		const diagnostic = { category: classifyError(error) };
 		const code = getSafeCode(error);
-		const status = getSafeStatus(error);
+		const status = extractErrorStatus(error);
 		const method = getSafeMethod(error);
 		const endpoint = getSafeEndpoint(error);
 		const frames = parseSafeStackFrames(error);
@@ -457,8 +522,255 @@ function createSafeErrorDiagnostic(error) {
 		return { category: "UnknownError" };
 	}
 }
+/** Resolve all bounded policy outputs used by MCP, telemetry, and reporting adapters. */
+function resolveErrorPolicy(error, defaultMessage, notInitializedMessage) {
+	const diagnostic = createSafeErrorDiagnostic(error);
+	let message = getStatusErrorMessage(diagnostic.status) ?? (diagnostic.status !== void 0 ? `Hevy API request failed (HTTP ${diagnostic.status}).` : defaultMessage);
+	let isNotInitialized = false;
+	try {
+		isNotInitialized = Boolean(notInitializedMessage) && error instanceof Error && error.message === notInitializedMessage;
+	} catch {
+		isNotInitialized = false;
+	}
+	if (isNotInitialized) message = notInitializedMessage ?? defaultMessage;
+	else if (isRetryExhausted(error)) message = getRetryExhaustedMessage(error);
+	else if (diagnostic.status === 429) message = getRateLimitMessage(error);
+	return {
+		type: determineErrorType(error, message),
+		message,
+		diagnostic
+	};
+}
 //#endregion
-//#region src/utils/formatters.ts
+//#region src/utils/response-formatter.ts
+function jsonText(data) {
+	return JSON.stringify(data, null, 2) ?? "null";
+}
+function textContent(text) {
+	return {
+		type: "text",
+		text
+	};
+}
+function defineStructuredResponseContract(definition) {
+	return {
+		outputSchema: definition.outputSchema,
+		render(data) {
+			const structuredContent = z.object(definition.outputSchema).parse(definition.normalize(data));
+			const text = definition.text?.(data, structuredContent) ?? jsonText(definition.legacyJson(structuredContent));
+			const additionalText = definition.additionalText?.(data, structuredContent) ?? [];
+			return {
+				content: [textContent(text), ...additionalText.map(textContent)],
+				structuredContent
+			};
+		}
+	};
+}
+function defineJsonResponseContract(present) {
+	return { render(data) {
+		const presentation = present(data);
+		return { content: [textContent(presentation.text ?? jsonText(presentation.json)), ...(presentation.additionalText ?? []).map(textContent)] };
+	} };
+}
+/** The only public success-response entry point used by tool handlers. */
+function respond(contract, data) {
+	return contract.render(data);
+}
+const optionalNullableNumber = z.number().nullable().optional();
+const formattedWorkoutSetSchema = z.object({
+	index: z.number().optional(),
+	type: z.string().optional(),
+	weight: optionalNullableNumber,
+	reps: optionalNullableNumber,
+	distance: optionalNullableNumber,
+	duration: optionalNullableNumber,
+	rpe: optionalNullableNumber,
+	customMetric: optionalNullableNumber
+});
+const formattedWorkoutExerciseSchema = z.object({
+	index: z.number().optional(),
+	name: z.string().optional(),
+	exerciseTemplateId: z.string().optional(),
+	notes: z.string().nullable().optional(),
+	supersetsId: optionalNullableNumber,
+	sets: z.array(formattedWorkoutSetSchema).optional()
+});
+const formattedWorkoutSchema = z.object({
+	id: z.string().optional(),
+	title: z.string().optional(),
+	description: z.string().nullable().optional(),
+	startTime: z.union([z.string(), z.number()]).optional(),
+	endTime: z.union([z.string(), z.number()]).optional(),
+	createdAt: z.string().optional(),
+	updatedAt: z.string().optional(),
+	duration: z.string(),
+	exercises: z.array(formattedWorkoutExerciseSchema).optional()
+});
+const formattedRoutineSetSchema = z.object({
+	index: z.number().optional(),
+	type: z.string().optional(),
+	weight: optionalNullableNumber,
+	reps: optionalNullableNumber,
+	distance: optionalNullableNumber,
+	duration: optionalNullableNumber,
+	customMetric: optionalNullableNumber,
+	repRange: z.object({
+		start: z.number().nullable().optional(),
+		end: z.number().nullable().optional()
+	}).nullable().optional(),
+	rpe: optionalNullableNumber
+});
+const formattedRoutineExerciseSchema = z.object({
+	name: z.string().optional(),
+	index: z.number().optional(),
+	exerciseTemplateId: z.string().optional(),
+	notes: z.string().nullable().optional(),
+	supersetId: optionalNullableNumber,
+	restSeconds: z.union([z.string(), z.number()]).nullable().optional(),
+	sets: z.array(formattedRoutineSetSchema).optional()
+});
+const formattedRoutineSchema = z.object({
+	id: z.string().optional(),
+	title: z.string().optional(),
+	folderId: z.number().nullable().optional(),
+	createdAt: z.string().optional(),
+	updatedAt: z.string().optional(),
+	exercises: z.array(formattedRoutineExerciseSchema).optional()
+});
+const formattedRoutineFolderSchema = z.object({
+	id: z.number().optional(),
+	title: z.string().optional(),
+	createdAt: z.string().optional(),
+	updatedAt: z.string().optional()
+});
+const formattedExerciseTemplateSchema = z.object({
+	id: z.string().optional(),
+	title: z.string().optional(),
+	type: z.string().optional(),
+	primaryMuscleGroup: z.string().optional(),
+	secondaryMuscleGroups: z.array(z.string()).optional(),
+	isCustom: z.boolean().optional()
+});
+const formattedExerciseHistoryEntrySchema = z.object({
+	workoutId: z.string().optional(),
+	workoutTitle: z.string().optional(),
+	workoutStartTime: z.string().optional(),
+	workoutEndTime: z.string().optional(),
+	exerciseTemplateId: z.string().optional(),
+	weight: optionalNullableNumber,
+	reps: optionalNullableNumber,
+	distance: optionalNullableNumber,
+	duration: optionalNullableNumber,
+	rpe: optionalNullableNumber,
+	customMetric: optionalNullableNumber,
+	setType: z.string().optional()
+});
+const formattedBodyMeasurementSchema = z.object({
+	date: z.string(),
+	weightKg: z.number().nullable(),
+	leanMassKg: z.number().nullable(),
+	fatPercent: z.number().nullable(),
+	neckCm: z.number().nullable(),
+	shoulderCm: z.number().nullable(),
+	chestCm: z.number().nullable(),
+	leftBicepCm: z.number().nullable(),
+	rightBicepCm: z.number().nullable(),
+	leftForearmCm: z.number().nullable(),
+	rightForearmCm: z.number().nullable(),
+	abdomen: z.number().nullable(),
+	waist: z.number().nullable(),
+	hips: z.number().nullable(),
+	leftThigh: z.number().nullable(),
+	rightThigh: z.number().nullable(),
+	leftCalf: z.number().nullable(),
+	rightCalf: z.number().nullable()
+});
+const workflowTelemetrySchema = z.object({
+	name: z.string(),
+	pagination: z.record(z.string(), z.number().int().nonnegative()),
+	cacheStatus: z.enum([
+		"hit",
+		"miss",
+		"not-used"
+	]),
+	itemsScanned: z.number().int().nonnegative()
+});
+const trainingSummarySessionSchema = z.object({
+	id: z.string().optional(),
+	title: z.string().optional(),
+	startTime: z.string().optional(),
+	endTime: z.string().optional(),
+	durationSeconds: z.number().int().nonnegative().nullable(),
+	exerciseCount: z.number().int().nonnegative(),
+	setCount: z.number().int().nonnegative()
+});
+const compactRoutineSchema = z.object({
+	id: z.string().optional(),
+	title: z.string().optional(),
+	folderId: z.number().nullable(),
+	updatedAt: z.string().optional(),
+	exerciseCount: z.number().int().nonnegative(),
+	setCount: z.number().int().nonnegative()
+});
+const workoutsOutputSchema = { workouts: z.array(formattedWorkoutSchema) };
+const workoutOutputSchema = { workout: formattedWorkoutSchema.nullable() };
+const workoutCountOutputSchema = { count: z.number().int() };
+const formattedUpdatedWorkoutSchema = z.object({
+	type: z.literal("updated"),
+	workout: formattedWorkoutSchema
+});
+const formattedDeletedWorkoutSchema = z.object({
+	type: z.literal("deleted"),
+	id: z.string(),
+	deletedAt: z.string().optional()
+});
+const workoutEventsOutputSchema = { events: z.array(z.union([formattedUpdatedWorkoutSchema, formattedDeletedWorkoutSchema])) };
+const routinesOutputSchema = { routines: z.array(formattedRoutineSchema) };
+const routineOutputSchema = { routine: formattedRoutineSchema.nullable() };
+const exerciseTemplatesOutputSchema = { exerciseTemplates: z.array(formattedExerciseTemplateSchema) };
+const exerciseTemplateOutputSchema = { exerciseTemplate: formattedExerciseTemplateSchema.nullable() };
+const exerciseHistoryOutputSchema = { exerciseHistory: z.array(formattedExerciseHistoryEntrySchema) };
+const routineFoldersOutputSchema = { routineFolders: z.array(formattedRoutineFolderSchema) };
+const routineFolderOutputSchema = { routineFolder: formattedRoutineFolderSchema.nullable() };
+const bodyMeasurementsOutputSchema = { bodyMeasurements: z.array(formattedBodyMeasurementSchema) };
+const bodyMeasurementOutputSchema = { bodyMeasurement: formattedBodyMeasurementSchema.nullable() };
+const userOutputSchema = { user: userInfoSchema.nullable() };
+const trainingSummaryOutputSchema = {
+	period: z.object({
+		startDate: z.string(),
+		endDate: z.string(),
+		weeks: z.number().int().positive()
+	}),
+	workouts: z.object({
+		count: z.number().int().nonnegative(),
+		totalDurationSeconds: z.number().int().nonnegative(),
+		exerciseCount: z.number().int().nonnegative(),
+		setCount: z.number().int().nonnegative(),
+		uniqueExerciseTemplateIds: z.array(z.string()),
+		sessions: z.array(trainingSummarySessionSchema)
+	}),
+	bodyMeasurements: z.object({
+		count: z.number().int().nonnegative(),
+		latest: z.object({
+			date: z.string(),
+			weightKg: z.number().nullable(),
+			leanMassKg: z.number().nullable(),
+			fatPercent: z.number().nullable()
+		}).nullable(),
+		earliest: z.object({
+			date: z.string(),
+			weightKg: z.number().nullable(),
+			leanMassKg: z.number().nullable(),
+			fatPercent: z.number().nullable()
+		}).nullable(),
+		weightChangeKg: z.number().nullable()
+	}),
+	workflow: workflowTelemetrySchema
+};
+const compactRoutinesOutputSchema = {
+	routines: z.array(compactRoutineSchema),
+	workflow: workflowTelemetrySchema
+};
 function getSupersetId(exercise) {
 	if (exercise.superset_id !== void 0) return exercise.superset_id;
 	if (exercise.supersets_id !== void 0) return exercise.supersets_id;
@@ -626,16 +938,137 @@ function formatBodyMeasurement(measurement) {
 		rightCalf: measurement.right_calf ?? null
 	};
 }
-//#endregion
-//#region src/utils/tool-helpers.ts
-const HEVY_CLIENT_NOT_INITIALIZED_ERROR = "API client not initialized. Please provide HEVY_API_KEY.";
-/**
-* Assert that the Hevy API client is initialized before running a tool.
-*/
-function requireClient(client) {
-	if (!client) throw new Error(HEVY_CLIENT_NOT_INITIALIZED_ERROR);
-	return client;
+function formatWorkoutEvent(event) {
+	if (event.type === "updated" && "workout" in event) return {
+		type: "updated",
+		workout: formatWorkout(event.workout)
+	};
+	if (event.type === "deleted" && "id" in event) return {
+		type: "deleted",
+		id: event.id,
+		deletedAt: event.deleted_at
+	};
+	throw new Error(`Unsupported workout event type: ${event.type}`);
 }
+const workoutsResponse = defineStructuredResponseContract({
+	outputSchema: workoutsOutputSchema,
+	normalize: (workouts) => ({ workouts: workouts?.map(formatWorkout) ?? [] }),
+	legacyJson: ({ workouts }) => workouts,
+	text: (_data, { workouts }) => workouts.length === 0 ? "No workouts found for the specified parameters" : void 0
+});
+const workoutResponse = defineStructuredResponseContract({
+	outputSchema: workoutOutputSchema,
+	normalize: (data) => ({ workout: data.workout ? formatWorkout(data.workout) : null }),
+	legacyJson: ({ workout }) => workout,
+	text: ({ workoutId }, { workout }) => workout === null ? `Workout with ID ${workoutId} not found` : void 0
+});
+const workoutCountResponse = defineStructuredResponseContract({
+	outputSchema: workoutCountOutputSchema,
+	normalize: (count) => ({ count }),
+	legacyJson: (output) => output
+});
+const workoutEventsResponse = defineStructuredResponseContract({
+	outputSchema: workoutEventsOutputSchema,
+	normalize: (data) => ({ events: data.events?.map(formatWorkoutEvent) ?? [] }),
+	legacyJson: ({ events }) => events,
+	text: ({ since }, { events }) => events.length === 0 ? `No workout events found for the specified parameters since ${since}` : void 0
+});
+const routinesResponse = defineStructuredResponseContract({
+	outputSchema: routinesOutputSchema,
+	normalize: (routines) => ({ routines: routines?.map(formatRoutine) ?? [] }),
+	legacyJson: ({ routines }) => routines,
+	text: (_data, { routines }) => routines.length === 0 ? "No routines found for the specified parameters" : void 0
+});
+const routineResponse = defineStructuredResponseContract({
+	outputSchema: routineOutputSchema,
+	normalize: (data) => ({ routine: data.routine ? formatRoutine(data.routine) : null }),
+	legacyJson: ({ routine }) => routine,
+	text: ({ routineId }, { routine }) => routine === null ? `Routine with ID ${routineId} not found` : void 0
+});
+const exerciseTemplatesResponse = defineStructuredResponseContract({
+	outputSchema: exerciseTemplatesOutputSchema,
+	normalize: (templates) => ({ exerciseTemplates: templates?.map(formatExerciseTemplate) ?? [] }),
+	legacyJson: ({ exerciseTemplates }) => exerciseTemplates,
+	text: (_data, { exerciseTemplates }) => exerciseTemplates.length === 0 ? "No exercise templates found for the specified parameters" : void 0
+});
+const exerciseTemplateResponse = defineStructuredResponseContract({
+	outputSchema: exerciseTemplateOutputSchema,
+	normalize: (data) => ({ exerciseTemplate: data.exerciseTemplate ? formatExerciseTemplate(data.exerciseTemplate) : null }),
+	legacyJson: ({ exerciseTemplate }) => exerciseTemplate,
+	text: ({ exerciseTemplateId }, { exerciseTemplate }) => exerciseTemplate === null ? `Exercise template with ID ${exerciseTemplateId} not found` : void 0
+});
+const exerciseHistoryResponse = defineStructuredResponseContract({
+	outputSchema: exerciseHistoryOutputSchema,
+	normalize: (data) => ({ exerciseHistory: data.history?.map(formatExerciseHistoryEntry) ?? [] }),
+	legacyJson: ({ exerciseHistory }) => exerciseHistory,
+	text: ({ exerciseTemplateId }, { exerciseHistory }) => exerciseHistory.length === 0 ? `No exercise history found for template ${exerciseTemplateId}` : void 0
+});
+const searchExerciseTemplatesResponse = defineStructuredResponseContract({
+	outputSchema: exerciseTemplatesOutputSchema,
+	normalize: (data) => ({ exerciseTemplates: data.results.map(formatExerciseTemplate) }),
+	legacyJson: ({ exerciseTemplates }) => exerciseTemplates,
+	text: ({ query, primaryMuscleGroup }, { exerciseTemplates }) => exerciseTemplates.length === 0 ? `No exercise templates found matching "${query}"${primaryMuscleGroup ? ` with primary muscle group "${primaryMuscleGroup}"` : ""}` : void 0
+});
+const routineFoldersResponse = defineStructuredResponseContract({
+	outputSchema: routineFoldersOutputSchema,
+	normalize: (folders) => ({ routineFolders: folders?.map(formatRoutineFolder) ?? [] }),
+	legacyJson: ({ routineFolders }) => routineFolders,
+	text: (_data, { routineFolders }) => routineFolders.length === 0 ? "No routine folders found for the specified parameters" : void 0
+});
+const routineFolderResponse = defineStructuredResponseContract({
+	outputSchema: routineFolderOutputSchema,
+	normalize: (data) => ({ routineFolder: data.routineFolder ? formatRoutineFolder(data.routineFolder) : null }),
+	legacyJson: ({ routineFolder }) => routineFolder,
+	text: ({ folderId }, { routineFolder }) => routineFolder === null ? `Routine folder with ID ${folderId} not found` : void 0
+});
+const bodyMeasurementsResponse = defineStructuredResponseContract({
+	outputSchema: bodyMeasurementsOutputSchema,
+	normalize: (measurements) => ({ bodyMeasurements: measurements?.map(formatBodyMeasurement) ?? [] }),
+	legacyJson: ({ bodyMeasurements }) => bodyMeasurements,
+	text: (_data, { bodyMeasurements }) => bodyMeasurements.length === 0 ? "No body measurements found for the specified parameters" : void 0
+});
+const bodyMeasurementResponse = defineStructuredResponseContract({
+	outputSchema: bodyMeasurementOutputSchema,
+	normalize: (data) => ({ bodyMeasurement: data.bodyMeasurement ? formatBodyMeasurement(data.bodyMeasurement) : null }),
+	legacyJson: ({ bodyMeasurement }) => bodyMeasurement,
+	text: ({ date }, { bodyMeasurement }) => bodyMeasurement === null ? `No body measurement found for date ${date}` : void 0
+});
+const userResponse = defineStructuredResponseContract({
+	outputSchema: userOutputSchema,
+	normalize: (user) => ({ user: user ?? null }),
+	legacyJson: ({ user }) => user,
+	text: (_data, { user }) => user === null ? "No user info found for the authenticated user" : void 0
+});
+const trainingSummaryResponse = defineStructuredResponseContract({
+	outputSchema: trainingSummaryOutputSchema,
+	normalize: (data) => data,
+	legacyJson: (output) => output,
+	text: (data) => data.workouts.count === 0 && data.bodyMeasurements.count === 0 ? "No workouts or body measurements found for the specified period" : void 0
+});
+const compactRoutinesResponse = defineStructuredResponseContract({
+	outputSchema: compactRoutinesOutputSchema,
+	normalize: (data) => data,
+	legacyJson: ({ routines }) => routines,
+	text: (_data, { routines }) => routines.length === 0 ? "No routines found matching the query" : void 0
+});
+const createWorkoutResponse = defineJsonResponseContract((workout) => workout ? { json: formatWorkout(workout) } : { text: "Failed to create workout: Server returned no data" });
+const updateWorkoutResponse = defineJsonResponseContract((data) => data.workout ? { json: formatWorkout(data.workout) } : { text: `Failed to update workout with ID ${data.workoutId}` });
+const repRangeDisplayWarningText = "Note: Hevy's public API stores rep ranges (rep_range), but the Hevy apps may not display them because they rely on an internal-only exercise field (input_modifier). See https://github.com/chrisdoc/hevy-mcp/issues/261 for details/workarounds.";
+const createRoutineResponse = defineJsonResponseContract((data) => data.routine ? {
+	json: formatRoutine(data.routine),
+	additionalText: data.usesRepRanges ? [repRangeDisplayWarningText] : []
+} : { text: "Failed to create routine: Server returned no data" });
+const updateRoutineResponse = defineJsonResponseContract((data) => data.routine ? {
+	json: formatRoutine(data.routine),
+	additionalText: data.usesRepRanges ? [repRangeDisplayWarningText] : []
+} : { text: `Failed to update routine with ID ${data.routineId}` });
+const createExerciseTemplateResponse = defineJsonResponseContract((response) => ({ json: {
+	id: response?.id,
+	message: "Exercise template created successfully"
+} }));
+const createRoutineFolderResponse = defineJsonResponseContract((folder) => folder ? { json: formatRoutineFolder(folder) } : { text: "Failed to create routine folder: Server returned no data" });
+const createBodyMeasurementResponse = defineJsonResponseContract((date) => ({ text: `Body measurement for ${date} created successfully.` }));
+const updateBodyMeasurementResponse = defineJsonResponseContract((date) => ({ text: `Body measurement for ${date} updated successfully.` }));
 //#endregion
 //#region src/resources/hevy.ts
 const JSON_MIME_TYPE = "application/json";
@@ -646,57 +1079,49 @@ function createJsonResourceResult(uri, data) {
 		text: JSON.stringify(data)
 	}] };
 }
-function getSafePageCount(data, currentPage) {
-	const pageCount = data?.page_count;
-	if (typeof pageCount !== "number" || !Number.isSafeInteger(pageCount) || pageCount < currentPage) return currentPage;
-	return pageCount;
-}
-async function fetchAllRoutineFolders(hevyClient) {
-	const allFolders = [];
-	let page = 1;
-	let pageCount = 1;
-	do {
-		const data = await hevyClient.getRoutineFolders({
+async function fetchAllRoutineFolders(runtime) {
+	const client = runtime.getClient();
+	return fetchAllPages(async (page, pageSize) => {
+		const data = await client.getRoutineFolders({
 			page,
-			pageSize: 10
+			pageSize
 		});
-		allFolders.push(...data?.routine_folders ?? []);
-		pageCount = getSafePageCount(data, page);
-		page++;
-	} while (page <= pageCount);
-	return allFolders;
+		return {
+			items: data?.routine_folders ?? [],
+			pageCount: data?.page_count
+		};
+	}, 10);
 }
-function registerHevyResources(server, hevyClient, catalog = createExerciseTemplateCatalog()) {
+function registerHevyResources(server, runtime) {
 	server.registerResource("user-profile", "hevy://user", {
 		description: "Authenticated Hevy user profile",
 		mimeType: JSON_MIME_TYPE
 	}, async (uri) => {
-		return createJsonResourceResult(uri, (await requireClient(hevyClient).getUserInfo())?.data ?? null);
+		return createJsonResourceResult(uri, (await runtime.getClient().getUserInfo())?.data ?? null);
 	});
 	server.registerResource("workout-count", "hevy://workout-count", {
 		description: "Total number of workouts in the Hevy account",
 		mimeType: JSON_MIME_TYPE
 	}, async (uri) => {
-		return createJsonResourceResult(uri, { count: (await requireClient(hevyClient).getWorkoutCount())?.workout_count ?? 0 });
+		return createJsonResourceResult(uri, { count: (await runtime.getClient().getWorkoutCount())?.workout_count ?? 0 });
 	});
 	server.registerResource("exercise-templates", "hevy://exercise-templates", {
 		description: "Full formatted Hevy exercise template catalog",
 		mimeType: JSON_MIME_TYPE
 	}, async (uri) => {
-		const client = requireClient(hevyClient);
-		return createJsonResourceResult(uri, (await catalog.get(client)).map(formatExerciseTemplate));
+		return createJsonResourceResult(uri, (await runtime.catalog.get()).map(formatExerciseTemplate));
 	});
 	server.registerResource("routine-folders", "hevy://routine-folders", {
 		description: "Full formatted list of Hevy routine folders",
 		mimeType: JSON_MIME_TYPE
 	}, async (uri) => {
-		return createJsonResourceResult(uri, (await fetchAllRoutineFolders(requireClient(hevyClient))).map(formatRoutineFolder));
+		return createJsonResourceResult(uri, (await fetchAllRoutineFolders(runtime)).map(formatRoutineFolder));
 	});
 }
 //#endregion
 //#region src/server-metadata.ts
 const SERVER_NAME = "hevy-mcp";
-const SERVER_VERSION = "3.1.1";
+const SERVER_VERSION = "3.2.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.",
@@ -705,349 +1130,64 @@ const SERVER_INSTRUCTIONS = [
 	"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
+//#region src/utils/tool-helpers.ts
 /**
-* Determine the type of error based on error characteristics.
+* Type-safe utilities for MCP tool handlers
 */
-function determineErrorType(error, message) {
-	if (error !== null && typeof error === "object" && error.hevyRetryExhausted === true) return "NETWORK_ERROR";
-	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";
-	if (nameLower.includes("validation") || messageLower.includes("validation") || messageLower.includes("invalid") || messageLower.includes("required")) return "VALIDATION_ERROR";
-	if (messageLower.includes("not found") || messageLower.includes("404") || messageLower.includes("does not exist")) return "NOT_FOUND";
-	if (nameLower.includes("api") || messageLower.includes("api") || messageLower.includes("server error") || messageLower.includes("500")) return "API_ERROR";
-	return "UNKNOWN_ERROR";
-}
-//#endregion
-//#region src/utils/error-handler.ts
+const HEVY_CLIENT_NOT_INITIALIZED_ERROR = "API client not initialized. Please provide HEVY_API_KEY.";
 /**
-* Centralized error handling utility for MCP tools
+* Assert that the Hevy API client is initialized before running a tool.
 */
-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 formatSecondsLabel(seconds) {
-	const roundedSeconds = Math.max(0, Math.round(seconds));
-	return `${roundedSeconds} second${roundedSeconds === 1 ? "" : "s"}`;
-}
-function getRateLimitMessage(error) {
-	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.`;
-	const retryAtMillis = Date.parse(retryAfterHeader);
-	if (!Number.isNaN(retryAtMillis)) return `Rate limited by Hevy (HTTP 429). Please wait about ${formatSecondsLabel(Math.ceil(Math.max(0, retryAtMillis - Date.now()) / 1e3))} before retrying.`;
-	return "Rate limited by Hevy (HTTP 429). Please wait and retry your request.";
-}
-function isRetryExhaustedError(error) {
-	return !!error && typeof error === "object" && error.hevyRetryExhausted === true;
-}
-function getRetryExhaustedMessage(error) {
-	const retryCount = typeof error === "object" && error !== null ? error.hevyRetryCount : void 0;
-	const attemptCount = typeof retryCount === "number" && Number.isFinite(retryCount) ? retryCount + 1 : void 0;
-	if (attemptCount) return `Unable to complete the request after ${attemptCount} attempts to the Hevy API due to transient failures. Please try again shortly.`;
-	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 (isHevyHttpError(error) && error.status === 429) return getRateLimitMessage(error);
-	return defaultMessage;
+function requireClient(client) {
+	if (!client) throw new Error(HEVY_CLIENT_NOT_INITIALIZED_ERROR);
+	return client;
 }
 /**
-* Create a standardized error response for MCP tools
+* Create a type-safe tool handler that validates and narrows args to inferred types
 *
-* @param error - The error object or message
-* @param context - Optional context information about where the error occurred
-* @returns A formatted MCP tool response with error information
+* This function wraps a handler with automatic Zod validation, ensuring runtime
+* type safety while maintaining compile-time type inference.
+*
+* @param schema - Zod schema object (e.g., { page: z.number(), ... })
+* @param handler - Handler function that receives validated, typed parameters
+* @returns A handler function that accepts Record<string, unknown> and validates it
+*
+* @example
+* ```typescript
+* const schema = {
+*   page: z.coerce.number().int().gte(1).default(1),
+*   pageSize: z.coerce.number().int().gte(1).lte(10).default(5),
+* } as const;
+*
+* const handler = createTypedToolHandler(schema, async (args) => {
+*   // args is fully typed as { page: number; pageSize: number }
+*   const { page, pageSize } = args;
+*   // ...
+* });
+* ```
 */
-function createErrorResponse(error, context) {
-	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;
-	else if (isHevyHttpError(error) && error.status !== void 0) errorMessage = `Hevy API request failed (HTTP ${error.status}).`;
-	errorMessage = getUserFacingMessage(error, errorMessage);
-	const errorCode = safeDiagnostic.code;
-	const errorType = determineErrorType(error, errorMessage);
-	const errorContext = {
-		sourceContext: context,
-		originalErrorMessage: `${safeDiagnostic.category} occurred`,
-		errorCode,
-		errorType,
-		axios: axiosErrorContext ?? void 0
-	};
-	const formattedMessage = `${context ? `[${context}] ` : ""}Error: ${errorMessage}`;
-	console.error("MCP tool failure", safeDiagnostic);
-	return {
-		content: [{
-			type: "text",
-			text: formattedMessage
-		}],
-		isError: true,
-		errorContext
-	};
-}
-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.";
-	if (status === 409) return "A conflict occurred (e.g., a body measurement already exists for this date). Use the update tool instead.";
-	if (status === 422) return "The request failed Hevy validation. Check the field values and try again.";
-	if (status === 429) return "Rate limited by Hevy. Please wait and retry.";
-	if (status && status >= 500 && status <= 599) return "Hevy API experienced an error. Please retry later.";
-	return null;
-}
-/**
-* Wrap an async function with standardized error handling
-*
-* This function preserves the parameter types of the wrapped function while
-* providing error handling. The returned function accepts Record<string, unknown>
-* (as required by MCP SDK) but internally casts to the original parameter type.
-*
-* @param fn - The async function to wrap
-* @param context - Context information for error messages
-* @returns A function that catches errors and returns standardized error responses
-*/
-function withErrorHandling(fn, context, onError) {
-	return async (rawArgs) => {
-		const args = rawArgs ?? {};
-		try {
-			return await fn(args);
-		} catch (error) {
-			try {
-				onError?.(error, context, Object.keys(args).length);
-			} catch {
-				console.error("MCP error observer failure", { category: "ObserverError" });
-			}
-			return createErrorResponse(error, context);
-		}
+function createTypedToolHandler(schema, handler) {
+	const zodSchema = z.object(schema);
+	return async (args) => {
+		return handler(zodSchema.parse(args));
 	};
 }
 //#endregion
-//#region src/generated/client/schemas/userInfoSchema.ts
-/**
-* Generated by Kubb (https://kubb.dev/).
-* Do not edit manually.
-*/
-const userInfoSchema = z$1.object({
-	id: z$1.optional(z$1.string().describe("The user ID.")),
-	name: z$1.optional(z$1.string().describe("The user's display name.")),
-	url: z$1.optional(z$1.string().describe("The user's public profile URL."))
-});
-//#endregion
-//#region src/utils/output-schemas.ts
-const optionalNullableNumber = z.number().nullable().optional();
-const formattedWorkoutSetSchema = z.object({
-	index: z.number().optional(),
-	type: z.string().optional(),
-	weight: optionalNullableNumber,
-	reps: optionalNullableNumber,
-	distance: optionalNullableNumber,
-	duration: optionalNullableNumber,
-	rpe: optionalNullableNumber,
-	customMetric: optionalNullableNumber
-});
-const formattedWorkoutExerciseSchema = z.object({
-	index: z.number().optional(),
-	name: z.string().optional(),
-	exerciseTemplateId: z.string().optional(),
-	notes: z.string().nullable().optional(),
-	supersetsId: optionalNullableNumber,
-	sets: z.array(formattedWorkoutSetSchema).optional()
-});
-const formattedWorkoutSchema = z.object({
-	id: z.string().optional(),
-	title: z.string().optional(),
-	description: z.string().nullable().optional(),
-	startTime: z.union([z.string(), z.number()]).optional(),
-	endTime: z.union([z.string(), z.number()]).optional(),
-	createdAt: z.string().optional(),
-	updatedAt: z.string().optional(),
-	duration: z.string(),
-	exercises: z.array(formattedWorkoutExerciseSchema).optional()
-});
-const formattedRoutineSetSchema = z.object({
-	index: z.number().optional(),
-	type: z.string().optional(),
-	weight: optionalNullableNumber,
-	reps: optionalNullableNumber,
-	distance: optionalNullableNumber,
-	duration: optionalNullableNumber,
-	customMetric: optionalNullableNumber,
-	repRange: z.object({
-		start: z.number().nullable().optional(),
-		end: z.number().nullable().optional()
-	}).nullable().optional(),
-	rpe: optionalNullableNumber
-});
-const formattedRoutineExerciseSchema = z.object({
-	name: z.string().optional(),
-	index: z.number().optional(),
-	exerciseTemplateId: z.string().optional(),
-	notes: z.string().nullable().optional(),
-	supersetId: optionalNullableNumber,
-	restSeconds: z.union([z.string(), z.number()]).nullable().optional(),
-	sets: z.array(formattedRoutineSetSchema).optional()
-});
-const formattedRoutineSchema = z.object({
-	id: z.string().optional(),
-	title: z.string().optional(),
-	folderId: z.number().nullable().optional(),
-	createdAt: z.string().optional(),
-	updatedAt: z.string().optional(),
-	exercises: z.array(formattedRoutineExerciseSchema).optional()
-});
-const formattedRoutineFolderSchema = z.object({
-	id: z.number().optional(),
-	title: z.string().optional(),
-	createdAt: z.string().optional(),
-	updatedAt: z.string().optional()
-});
-const formattedExerciseTemplateSchema = z.object({
-	id: z.string().optional(),
-	title: z.string().optional(),
-	type: z.string().optional(),
-	primaryMuscleGroup: z.string().optional(),
-	secondaryMuscleGroups: z.array(z.string()).optional(),
-	isCustom: z.boolean().optional()
-});
-const formattedExerciseHistoryEntrySchema = z.object({
-	workoutId: z.string().optional(),
-	workoutTitle: z.string().optional(),
-	workoutStartTime: z.string().optional(),
-	workoutEndTime: z.string().optional(),
-	exerciseTemplateId: z.string().optional(),
-	weight: optionalNullableNumber,
-	reps: optionalNullableNumber,
-	distance: optionalNullableNumber,
-	duration: optionalNullableNumber,
-	rpe: optionalNullableNumber,
-	customMetric: optionalNullableNumber,
-	setType: z.string().optional()
-});
-const formattedBodyMeasurementSchema = z.object({
-	date: z.string(),
-	weightKg: z.number().nullable(),
-	leanMassKg: z.number().nullable(),
-	fatPercent: z.number().nullable(),
-	neckCm: z.number().nullable(),
-	shoulderCm: z.number().nullable(),
-	chestCm: z.number().nullable(),
-	leftBicepCm: z.number().nullable(),
-	rightBicepCm: z.number().nullable(),
-	leftForearmCm: z.number().nullable(),
-	rightForearmCm: z.number().nullable(),
-	abdomen: z.number().nullable(),
-	waist: z.number().nullable(),
-	hips: z.number().nullable(),
-	leftThigh: z.number().nullable(),
-	rightThigh: z.number().nullable(),
-	leftCalf: z.number().nullable(),
-	rightCalf: z.number().nullable()
-});
-const workoutsOutputSchema = { workouts: z.array(formattedWorkoutSchema) };
-const workoutOutputSchema = { workout: formattedWorkoutSchema.nullable() };
-const workoutCountOutputSchema = { count: z.number().int() };
-const formattedUpdatedWorkoutSchema = z.object({
-	type: z.literal("updated"),
-	workout: formattedWorkoutSchema
-});
-const formattedDeletedWorkoutSchema = z.object({
-	type: z.literal("deleted"),
-	id: z.string(),
-	deletedAt: z.string().optional()
-});
-const workoutEventsOutputSchema = { events: z.array(z.union([formattedUpdatedWorkoutSchema, formattedDeletedWorkoutSchema])) };
-const routinesOutputSchema = { routines: z.array(formattedRoutineSchema) };
-const routineOutputSchema = { routine: formattedRoutineSchema.nullable() };
-const exerciseTemplatesOutputSchema = { exerciseTemplates: z.array(formattedExerciseTemplateSchema) };
-const exerciseTemplateOutputSchema = { exerciseTemplate: formattedExerciseTemplateSchema.nullable() };
-const exerciseHistoryOutputSchema = { exerciseHistory: z.array(formattedExerciseHistoryEntrySchema) };
-const routineFoldersOutputSchema = { routineFolders: z.array(formattedRoutineFolderSchema) };
-const routineFolderOutputSchema = { routineFolder: formattedRoutineFolderSchema.nullable() };
-const bodyMeasurementsOutputSchema = { bodyMeasurements: z.array(formattedBodyMeasurementSchema) };
-const bodyMeasurementOutputSchema = { bodyMeasurement: formattedBodyMeasurementSchema.nullable() };
-const userOutputSchema = { user: userInfoSchema.nullable() };
-//#endregion
-//#region src/utils/response-formatter.ts
-/**
-* Create a standardized success response with JSON data
-*
-* @param data - The data to include in the response
-* @param options - Formatting options
-* @returns A formatted MCP tool response with the data as JSON
-*/
-function createJsonResponse(data, options = {
-	pretty: true,
-	indent: 2
-}) {
-	return { content: [{
-		type: "text",
-		text: (options.pretty ? JSON.stringify(data, null, options.indent) : JSON.stringify(data)) ?? "null"
-	}] };
-}
-/**
-* Create a JSON text response with a typed machine-readable payload.
-*
-* The text content is produced by the legacy JSON formatter so existing MCP
-* clients receive byte-for-byte identical output.
-*/
-function createStructuredJsonResponse(data, structuredContent, options = {
-	pretty: true,
-	indent: 2
-}) {
-	return {
-		...createJsonResponse(data, options),
-		structuredContent
-	};
-}
-/**
-* Create a standardized success response with text data
-*
-* @param message - The text message to include in the response
-* @returns A formatted MCP tool response with the text message
-*/
-function createTextResponse(message) {
-	return { content: [{
-		type: "text",
-		text: message
-	}] };
-}
-/**
-* Create a standardized success response for empty or null results
-*
-* @param message - Optional message to include (default: "No data found")
-* @returns A formatted MCP tool response for empty results
-*/
-function createEmptyResponse(message = "No data found") {
-	return createTextResponse(message);
-}
-/**
-* Create an empty/not-found text response with a valid structured payload.
-*/
-function createStructuredEmptyResponse(message, structuredContent) {
-	return {
-		...createEmptyResponse(message),
-		structuredContent
-	};
+//#region src/tools/define-tool.ts
+function registerToolDefinition(server, runtime, definition) {
+	const directHandler = createTypedToolHandler(definition.inputSchema, async (args) => respond(definition.responseContract, await definition.execute(runtime, args)));
+	const handler = runtime.wrapHandler(directHandler, definition.name);
+	const callback = (args) => handler(args);
+	if (definition.kind === "read") {
+		server.registerTool(definition.name, {
+			description: definition.description,
+			inputSchema: definition.inputSchema,
+			outputSchema: definition.outputSchema,
+			annotations: definition.annotations
+		}, callback);
+		return;
+	}
+	server.tool(definition.name, definition.description, definition.inputSchema, definition.annotations, callback);
 }
 //#endregion
 //#region src/utils/tool-annotations.ts
@@ -1093,76 +1233,92 @@ function describeTool({ summary, aliases, useCase, importantNotes }) {
 	].join(" ");
 }
 //#endregion
-//#region src/utils/schemas.ts
-function coerceNullishNumberInput(value) {
-	if (value === null || value === void 0) return value;
-	if (typeof value !== "string") return value;
-	const trimmed = value.trim();
-	if (trimmed === "") return;
-	const lowered = trimmed.toLowerCase();
-	if (lowered === "null") return null;
-	if (lowered === "undefined") return;
-	const asNumber = Number(trimmed);
-	if (Number.isNaN(asNumber)) return value;
-	return asNumber;
+//#region src/utils/json-parser.ts
+/**
+* Preprocessor to handle MCP clients that send JSON-stringified arrays
+* instead of native arrays for complex parameters.
+*
+* This is used with Zod's z.preprocess to handle cases where MCP clients
+* serialize complex nested structures as JSON strings.
+*
+* @param val - The value to potentially parse
+* @returns The parsed array if val is a valid JSON string, otherwise returns val unchanged
+*/
+function parseJsonArray(val) {
+	if (typeof val === "string") try {
+		return JSON.parse(val);
+	} catch {
+		return val;
+	}
+	return val;
 }
-const zNullableInt = z.preprocess(coerceNullishNumberInput, z.number().int().nullable().optional());
-const zNullableNumber = z.preprocess((value) => value === "" ? void 0 : value, z.coerce.number().nullable().optional());
-const zOptionalRepRange = z.preprocess((value) => value === null ? void 0 : value, z.object({
-	start: zNullableInt,
-	end: zNullableInt
-}).optional());
-const setTypeEnum = z.enum([
-	"warmup",
-	"normal",
-	"failure",
-	"dropset"
-]).default("normal");
-const muscleGroupEnum = z.enum([
-	"abdominals",
-	"shoulders",
-	"biceps",
-	"triceps",
-	"forearms",
-	"quadriceps",
-	"hamstrings",
-	"calves",
-	"glutes",
-	"abductors",
-	"adductors",
-	"lats",
-	"upper_back",
-	"traps",
-	"lower_back",
-	"chest",
-	"cardio",
-	"neck",
-	"full_body",
-	"other"
-]);
-const exerciseTypeEnum = z.enum([
-	"weight_reps",
-	"reps_only",
-	"bodyweight_reps",
-	"bodyweight_assisted_reps",
-	"duration",
-	"weight_duration",
-	"distance_duration",
-	"short_distance_weight"
-]);
-const equipmentCategoryEnum = z.enum([
-	"none",
-	"barbell",
-	"dumbbell",
-	"kettlebell",
-	"machine",
-	"plate",
-	"resistance_band",
-	"suspension",
-	"other"
-]);
 //#endregion
-//#region src/tools/body-measurements.ts
+//#region src/tools/input-schemas.ts
+/** Build the page and pageSize fields shared by paginated tools. */
+function paginationShape({ defaultPageSize, maxPageSize, integerPage = true }) {
+	const pageNumber = z.coerce.number().gte(1);
+	return {
+		page: integerPage ? pageNumber.int() : pageNumber,
+		pageSize: z.coerce.number().int().gte(1).lte(maxPageSize).default(defaultPageSize)
+	};
+}
+const nonEmptyId = z.string().min(1);
+const CALENDAR_DATE_MESSAGE = "Date must be in YYYY-MM-DD format";
+const calendarDate = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, CALENDAR_DATE_MESSAGE).refine((value) => {
+	const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+	return !Number.isNaN(parsed.getTime()) && parsed.toISOString().startsWith(value);
+}, CALENDAR_DATE_MESSAGE);
+const workoutSetShape = {
+	type: setTypeEnum,
+	weight: z.coerce.number().optional().nullable(),
+	weightKg: z.coerce.number().optional().nullable(),
+	reps: z.coerce.number().int().optional().nullable(),
+	distance: z.coerce.number().int().optional().nullable(),
+	distanceMeters: z.coerce.number().int().optional().nullable(),
+	duration: z.coerce.number().int().optional().nullable(),
+	durationSeconds: z.coerce.number().int().optional().nullable(),
+	rpe: z.coerce.number().optional().nullable(),
+	customMetric: z.coerce.number().optional().nullable()
+};
+const workoutExerciseShape = {
+	exerciseTemplateId: nonEmptyId,
+	supersetId: z.coerce.number().nullable().optional(),
+	notes: z.string().optional().nullable(),
+	sets: z.array(z.object(workoutSetShape))
+};
+const workoutPayloadShape = {
+	title: z.string().min(1),
+	description: z.string().optional().nullable(),
+	startTime: utcSecondTimestamp,
+	endTime: utcSecondTimestamp,
+	isPrivate: z.boolean().default(false),
+	exercises: z.preprocess(parseJsonArray, z.array(z.object(workoutExerciseShape)))
+};
+const routineSetShape = {
+	type: setTypeEnum,
+	weight: z.coerce.number().optional(),
+	weightKg: z.coerce.number().optional(),
+	reps: zNullableInt,
+	distance: z.coerce.number().int().optional(),
+	distanceMeters: z.coerce.number().int().optional(),
+	duration: z.coerce.number().int().optional(),
+	durationSeconds: z.coerce.number().int().optional(),
+	customMetric: z.coerce.number().optional(),
+	repRange: zOptionalRepRange
+};
+const routineExerciseShape = {
+	exerciseTemplateId: nonEmptyId,
+	supersetId: z.coerce.number().nullable().optional(),
+	restSeconds: z.coerce.number().int().min(0).optional(),
+	notes: z.string().optional(),
+	sets: z.array(z.object(routineSetShape))
+};
+const routinePayloadShape = {
+	title: z.string().min(1),
+	folderId: z.coerce.number().nullable().optional(),
+	notes: z.string().optional(),
+	exercises: z.preprocess(parseJsonArray, z.array(z.object(routineExerciseShape)))
+};
 const bodyMeasurementFieldsSchema = {
 	weightKg: zNullableNumber.describe("Body weight in kilograms"),
 	leanMassKg: zNullableNumber.describe("Lean body mass in kilograms"),
@@ -1182,7 +1338,7 @@ const bodyMeasurementFieldsSchema = {
 	leftCalf: zNullableNumber.describe("Left calf circumference in centimeters"),
 	rightCalf: zNullableNumber.describe("Right calf circumference in centimeters")
 };
-const MEASUREMENT_FIELD_TO_API_KEY = {
+const measurementFieldToApiKey = {
 	weightKg: "weight_kg",
 	leanMassKg: "lean_mass_kg",
 	fatPercent: "fat_percent",
@@ -1201,20 +1357,130 @@ const MEASUREMENT_FIELD_TO_API_KEY = {
 	leftCalf: "left_calf",
 	rightCalf: "right_calf"
 };
-function buildMeasurementPayload(args) {
+//#endregion
+//#region src/tools/payload-mappers.ts
+/** Map the public camelCase workout input to the API's snake_case payload. */
+function buildWorkoutPayload(input) {
+	return {
+		title: input.title,
+		description: input.description ?? null,
+		start_time: input.startTime,
+		end_time: input.endTime,
+		is_private: input.isPrivate,
+		exercises: input.exercises.map((exercise) => ({
+			exercise_template_id: exercise.exerciseTemplateId,
+			superset_id: exercise.supersetId ?? null,
+			notes: exercise.notes ?? null,
+			sets: exercise.sets.map((set) => ({
+				type: set.type,
+				weight_kg: set.weight ?? set.weightKg ?? null,
+				reps: set.reps ?? null,
+				distance_meters: set.distance ?? set.distanceMeters ?? null,
+				duration_seconds: set.duration ?? set.durationSeconds ?? null,
+				rpe: set.rpe ?? null,
+				custom_metric: set.customMetric ?? null
+			}))
+		}))
+	};
+}
+function buildRepRange(repRange) {
+	if (!repRange) return null;
+	const start = repRange.start ?? void 0;
+	const end = repRange.end ?? void 0;
+	if (start === void 0 && end === void 0) return null;
+	return {
+		start,
+		end
+	};
+}
+function getFixedRepsFromRepRange(repRange) {
+	if (!repRange) return null;
+	const start = repRange.start ?? null;
+	const end = repRange.end ?? null;
+	if (start === null || end === null || start !== end) return null;
+	return start;
+}
+function buildRoutineSets(sets, mode) {
+	return sets.map((set) => {
+		const repRange = buildRepRange(set.repRange);
+		const reps = typeof set.reps === "number" ? set.reps : getFixedRepsFromRepRange(repRange);
+		const common = {
+			weight_kg: set.weight ?? set.weightKg ?? null,
+			reps: reps ?? null,
+			distance_meters: set.distance ?? set.distanceMeters ?? null,
+			duration_seconds: set.duration ?? set.durationSeconds ?? null,
+			custom_metric: set.customMetric ?? null
+		};
+		if (mode === "create") return {
+			...common,
+			type: set.type,
+			rep_range: repRange
+		};
+		return {
+			...common,
+			type: set.type,
+			...repRange ? { rep_range: repRange } : {}
+		};
+	});
+}
+function buildRoutinePayload(input, mode) {
+	let usesRepRanges = false;
+	const exercises = input.exercises.map((exercise) => {
+		const sets = buildRoutineSets(exercise.sets, mode);
+		if (sets.some((set) => set.rep_range != null && getFixedRepsFromRepRange(set.rep_range) === null)) usesRepRanges = true;
+		return {
+			exercise_template_id: exercise.exerciseTemplateId,
+			superset_id: exercise.supersetId ?? null,
+			rest_seconds: exercise.restSeconds ?? null,
+			notes: exercise.notes ?? null,
+			sets
+		};
+	});
+	if (mode === "create") return {
+		payload: {
+			title: input.title,
+			folder_id: input.folderId ?? null,
+			notes: input.notes ?? "",
+			exercises
+		},
+		usesRepRanges
+	};
+	return {
+		payload: {
+			title: input.title,
+			notes: input.notes ?? null,
+			exercises
+		},
+		usesRepRanges
+	};
+}
+/** Omit nullish measurement values because the API rejects explicit nulls. */
+function buildMeasurementPayload(fields) {
 	const payload = {};
-	for (const [camelKey, apiKey] of Object.entries(MEASUREMENT_FIELD_TO_API_KEY)) {
-		const value = args[camelKey];
+	for (const [camelKey, apiKey] of Object.entries(measurementFieldToApiKey)) {
+		const value = fields[camelKey];
 		if (value != null) payload[apiKey] = value;
 	}
 	return payload;
 }
-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)
-	};
-	server.registerTool("get-body-measurements", {
+//#endregion
+//#region src/tools/body-measurements.ts
+const getBodyMeasurementsSchema = { ...paginationShape({
+	defaultPageSize: 10,
+	maxPageSize: 10
+}) };
+const getBodyMeasurementSchema = { date: calendarDate.describe("The date of the body measurement (YYYY-MM-DD)") };
+const createBodyMeasurementSchema = {
+	date: calendarDate.describe("The date of the body measurement (YYYY-MM-DD). Must be unique — returns 409 if an entry already exists for this date."),
+	...bodyMeasurementFieldsSchema
+};
+const updateBodyMeasurementSchema = {
+	date: calendarDate.describe("The date of the body measurement to update (YYYY-MM-DD). Must already exist — returns 404 otherwise."),
+	...bodyMeasurementFieldsSchema
+};
+const bodyMeasurementToolDefinitions = [
+	{
+		name: "get-body-measurements",
 		description: describeTool({
 			summary: "Read-only. Lists dated body measurements for the account.",
 			aliases: [
@@ -1226,20 +1492,20 @@ function registerBodyMeasurementTools(server, hevyClient, wrapHandler = withErro
 			importantNotes: "Results are paginated; page starts at 1 and pageSize is limited to 10."
 		}),
 		inputSchema: getBodyMeasurementsSchema,
-		outputSchema: bodyMeasurementsOutputSchema,
-		annotations: readOnlyAnnotations("Get Body Measurements")
-	}, wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { page, pageSize } = args;
-		const measurements = (await client.getBodyMeasurements({
-			page,
-			pageSize
-		}))?.body_measurements?.map((measurement) => formatBodyMeasurement(measurement)) || [];
-		if (measurements.length === 0) return createStructuredEmptyResponse("No body measurements found for the specified parameters", { bodyMeasurements: [] });
-		return createStructuredJsonResponse(measurements, { bodyMeasurements: measurements });
-	}, "get-body-measurements"));
-	const getBodyMeasurementSchema = { date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").describe("The date of the body measurement (YYYY-MM-DD)") };
-	server.registerTool("get-body-measurement", {
+		outputSchema: bodyMeasurementsResponse.outputSchema,
+		annotations: readOnlyAnnotations("Get Body Measurements"),
+		kind: "read",
+		responseContract: bodyMeasurementsResponse,
+		execute: async (runtime, args) => {
+			const { page, pageSize } = args;
+			return (await runtime.getClient().getBodyMeasurements({
+				page,
+				pageSize
+			}))?.body_measurements;
+		}
+	},
+	{
+		name: "get-body-measurement",
 		description: describeTool({
 			summary: "Read-only. Retrieves the body measurement entry for one date.",
 			aliases: [
@@ -1251,71 +1517,79 @@ function registerBodyMeasurementTools(server, hevyClient, wrapHandler = withErro
 			importantNotes: "date must use YYYY-MM-DD; at most one entry exists per date."
 		}),
 		inputSchema: getBodyMeasurementSchema,
-		outputSchema: bodyMeasurementOutputSchema,
-		annotations: readOnlyAnnotations("Get Body Measurement")
-	}, wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { date } = args;
-		const data = await client.getBodyMeasurement(date);
-		if (!data) return createStructuredEmptyResponse(`No body measurement found for date ${date}`, { bodyMeasurement: null });
-		const bodyMeasurement = formatBodyMeasurement(data);
-		return createStructuredJsonResponse(bodyMeasurement, { bodyMeasurement });
-	}, "get-body-measurement"));
-	const createBodyMeasurementSchema = {
-		date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").describe("The date of the body measurement (YYYY-MM-DD). Must be unique — returns 409 if an entry already exists for this date."),
-		...bodyMeasurementFieldsSchema
-	};
-	server.tool("create-body-measurement", describeTool({
-		summary: "Writes to the Hevy account by creating a dated body measurement.",
-		aliases: [
-			"log weigh-in",
-			"add body stats",
-			"record measurements"
-		],
-		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"), wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { date, ...fields } = args;
-		await client.createBodyMeasurement({
-			date,
-			...buildMeasurementPayload(fields)
-		});
-		return createTextResponse(`Body measurement for ${date} created successfully.`);
-	}, "create-body-measurement"));
-	const updateBodyMeasurementSchema = {
-		date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").describe("The date of the body measurement to update (YYYY-MM-DD). Must already exist — returns 404 otherwise."),
-		...bodyMeasurementFieldsSchema
-	};
-	server.tool("update-body-measurement", describeTool({
-		summary: "Mutates the Hevy account by updating a body measurement for a date.",
-		aliases: [
-			"edit weigh-in",
-			"correct body stats",
-			"change measurements"
-		],
-		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"), wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { date, ...fields } = args;
-		const payload = buildMeasurementPayload(fields);
-		if (Object.keys(payload).length === 0) throw new Error("No measurement fields provided. Include at least one numeric measurement field (e.g. weightKg) to update.");
-		await client.updateBodyMeasurement(date, payload);
-		return createTextResponse(`Body measurement for ${date} updated successfully.`);
-	}, "update-body-measurement"));
-}
+		outputSchema: bodyMeasurementResponse.outputSchema,
+		annotations: readOnlyAnnotations("Get Body Measurement"),
+		kind: "read",
+		responseContract: bodyMeasurementResponse,
+		execute: async (runtime, args) => {
+			const { date } = args;
+			return {
+				bodyMeasurement: await runtime.getClient().getBodyMeasurement(date),
+				date
+			};
+		}
+	},
+	{
+		name: "create-body-measurement",
+		description: describeTool({
+			summary: "Writes to the Hevy account by creating a dated body measurement.",
+			aliases: [
+				"log weigh-in",
+				"add body stats",
+				"record measurements"
+			],
+			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."
+		}),
+		inputSchema: createBodyMeasurementSchema,
+		annotations: createAnnotations("Create Body Measurement"),
+		kind: "write",
+		responseContract: createBodyMeasurementResponse,
+		execute: async (runtime, args) => {
+			const { date, ...fields } = args;
+			await runtime.getClient().createBodyMeasurement({
+				date,
+				...buildMeasurementPayload(fields)
+			});
+			return date;
+		}
+	},
+	{
+		name: "update-body-measurement",
+		description: describeTool({
+			summary: "Mutates the Hevy account by updating a body measurement for a date.",
+			aliases: [
+				"edit weigh-in",
+				"correct body stats",
+				"change measurements"
+			],
+			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."
+		}),
+		inputSchema: updateBodyMeasurementSchema,
+		annotations: updateAnnotations("Update Body Measurement"),
+		kind: "write",
+		responseContract: updateBodyMeasurementResponse,
+		execute: async (runtime, args) => {
+			const { date, ...fields } = args;
+			const payload = buildMeasurementPayload(fields);
+			if (Object.keys(payload).length === 0) throw new Error("No measurement fields provided. Include at least one numeric measurement field (e.g. weightKg) to update.");
+			await runtime.getClient().updateBodyMeasurement(date, payload);
+			return date;
+		}
+	}
+];
 //#endregion
 //#region src/tools/folders.ts
-/**
-* Register all routine folder-related tools with the MCP server
-*/
-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)
-	};
-	server.registerTool("get-routine-folders", {
+const getRoutineFoldersSchema = paginationShape({
+	defaultPageSize: 5,
+	maxPageSize: 10
+});
+const getRoutineFolderSchema = { folderId: nonEmptyId };
+const createRoutineFolderSchema = { name: z.string().min(1) };
+const folderToolDefinitions = [
+	{
+		name: "get-routine-folders",
 		description: describeTool({
 			summary: "Read-only. Lists default and custom routine folders.",
 			aliases: [
@@ -1327,20 +1601,20 @@ function registerFolderTools(server, hevyClient, wrapHandler = withErrorHandling
 			importantNotes: "Results are paginated; page starts at 1 and pageSize is limited to 10."
 		}),
 		inputSchema: getRoutineFoldersSchema,
-		outputSchema: routineFoldersOutputSchema,
-		annotations: readOnlyAnnotations("Get Routine Folders")
-	}, wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { page, pageSize } = args;
-		const folders = (await client.getRoutineFolders({
-			page,
-			pageSize
-		}))?.routine_folders?.map((folder) => formatRoutineFolder(folder)) || [];
-		if (folders.length === 0) return createStructuredEmptyResponse("No routine folders found for the specified parameters", { routineFolders: [] });
-		return createStructuredJsonResponse(folders, { routineFolders: folders });
-	}, "get-routine-folders"));
-	const getRoutineFolderSchema = { folderId: z.string().min(1) };
-	server.registerTool("get-routine-folder", {
+		outputSchema: routineFoldersResponse.outputSchema,
+		annotations: readOnlyAnnotations("Get Routine Folders"),
+		kind: "read",
+		responseContract: routineFoldersResponse,
+		execute: async (runtime, args) => {
+			const { page, pageSize } = args;
+			return (await runtime.getClient().getRoutineFolders({
+				page,
+				pageSize
+			}))?.routine_folders;
+		}
+	},
+	{
+		name: "get-routine-folder",
 		description: describeTool({
 			summary: "Read-only. Retrieves one routine folder's metadata by ID.",
 			aliases: [
@@ -1352,161 +1626,100 @@ function registerFolderTools(server, hevyClient, wrapHandler = withErrorHandling
 			importantNotes: "Requires a folderId from get-routine-folders or a prior create response."
 		}),
 		inputSchema: getRoutineFolderSchema,
-		outputSchema: routineFolderOutputSchema,
-		annotations: readOnlyAnnotations("Get Routine Folder")
-	}, wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { folderId } = args;
-		const data = await client.getRoutineFolder(folderId);
-		if (!data) return createStructuredEmptyResponse(`Routine folder with ID ${folderId} not found`, { routineFolder: null });
-		const folder = formatRoutineFolder(data);
-		return createStructuredJsonResponse(folder, { routineFolder: folder });
-	}, "get-routine-folder"));
-	const createRoutineFolderSchema = { name: z.string().min(1) };
-	server.tool("create-routine-folder", describeTool({
-		summary: "Writes to the Hevy account by creating a new routine folder.",
-		aliases: [
-			"add folder",
-			"organize routines",
-			"create plan group"
-		],
-		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"), wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { name } = args;
-		const data = await client.createRoutineFolder({ routine_folder: { title: name } });
-		if (!data) return createEmptyResponse("Failed to create routine folder: Server returned no data");
-		return createJsonResponse(formatRoutineFolder(data), {
-			pretty: true,
-			indent: 2
-		});
-	}, "create-routine-folder"));
-}
-//#endregion
-//#region src/utils/json-parser.ts
-/**
-* Preprocessor to handle MCP clients that send JSON-stringified arrays
-* instead of native arrays for complex parameters.
-*
-* This is used with Zod's z.preprocess to handle cases where MCP clients
-* serialize complex nested structures as JSON strings.
-*
-* @param val - The value to potentially parse
-* @returns The parsed array if val is a valid JSON string, otherwise returns val unchanged
-*/
-function parseJsonArray(val) {
-	if (typeof val === "string") try {
-		return JSON.parse(val);
-	} catch {
-		return val;
-	}
-	return val;
-}
-//#endregion
-//#region src/tools/routines.ts
-function buildRepRange(repRange) {
-	if (!repRange) return null;
-	const start = repRange.start ?? void 0;
-	const end = repRange.end ?? void 0;
-	if (start === void 0 && end === void 0) return null;
-	return {
-		start,
-		end
-	};
-}
-/**
-* Returns a fixed rep count when `repRange` is a fixed range (start and end are
-* both non-null and equal). Otherwise returns null.
-*/
-function getFixedRepsFromRepRange(repRange) {
-	if (!repRange) return null;
-	const start = repRange.start ?? null;
-	const end = repRange.end ?? null;
-	if (start === null || end === null) return null;
-	if (start !== end) return null;
-	return start;
-}
-const repRangeDisplayWarningText = "Note: Hevy's public API stores rep ranges (rep_range), but the Hevy apps may not display them because they rely on an internal-only exercise field (input_modifier). See https://github.com/chrisdoc/hevy-mcp/issues/261 for details/workarounds.";
-/**
-* Register all routine-related tools with the MCP server
-*/
-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)
-	};
-	server.registerTool("get-routines", {
+		outputSchema: routineFolderResponse.outputSchema,
+		annotations: readOnlyAnnotations("Get Routine Folder"),
+		kind: "read",
+		responseContract: routineFolderResponse,
+		execute: async (runtime, args) => {
+			const { folderId } = args;
+			return {
+				routineFolder: await runtime.getClient().getRoutineFolder(folderId),
+				folderId
+			};
+		}
+	},
+	{
+		name: "create-routine-folder",
 		description: describeTool({
-			summary: "Read-only. Lists custom and default workout routines.",
+			summary: "Writes to the Hevy account by creating a new routine folder.",
 			aliases: [
-				"list routines",
-				"show workout plans",
-				"browse saved routines"
+				"add folder",
+				"organize routines",
+				"create plan group"
 			],
-			useCase: "Use to browse routines or discover a routine ID; use get-routine for one known routine.",
-			importantNotes: "Results are paginated; page starts at 1 and pageSize is limited to 10."
+			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."
 		}),
-		inputSchema: getRoutinesSchema,
-		outputSchema: routinesOutputSchema,
-		annotations: readOnlyAnnotations("Get Routines")
-	}, wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { page, pageSize } = args;
-		const routines = (await client.getRoutines({
+		inputSchema: createRoutineFolderSchema,
+		annotations: createAnnotations("Create Routine Folder"),
+		kind: "write",
+		responseContract: createRoutineFolderResponse,
+		execute: async (runtime, args) => {
+			const { name } = args;
+			return runtime.getClient().createRoutineFolder({ routine_folder: { title: name } });
+		}
+	}
+];
+//#endregion
+//#region src/tools/routines.ts
+const getRoutinesSchema = paginationShape({
+	defaultPageSize: 5,
+	maxPageSize: 10
+});
+const getRoutinesDefinition = {
+	name: "get-routines",
+	description: describeTool({
+		summary: "Read-only. Lists custom and default workout routines.",
+		aliases: [
+			"list routines",
+			"show workout plans",
+			"browse saved routines"
+		],
+		useCase: "Use to browse routines or discover a routine ID; use get-routine for one known routine.",
+		importantNotes: "Results are paginated; page starts at 1 and pageSize is limited to 10."
+	}),
+	inputSchema: getRoutinesSchema,
+	kind: "read",
+	outputSchema: routinesResponse.outputSchema,
+	annotations: readOnlyAnnotations("Get Routines"),
+	responseContract: routinesResponse,
+	execute: async (runtime, { page, pageSize }) => {
+		return (await runtime.getClient().getRoutines({
 			page,
 			pageSize
-		}))?.routines?.map((routine) => formatRoutine(routine)) || [];
-		if (routines.length === 0) return createStructuredEmptyResponse("No routines found for the specified parameters", { routines: [] });
-		return createStructuredJsonResponse(routines, { routines });
-	}, "get-routines"));
-	const getRoutineSchema = { routineId: z.string().min(1) };
-	server.registerTool("get-routine", {
-		description: describeTool({
-			summary: "Read-only. Retrieves one routine and its exercise configuration by ID.",
-			aliases: [
-				"show routine",
-				"fetch workout plan",
-				"routine details"
-			],
-			useCase: "Use when the routineId is known; use get-routines to browse or discover IDs.",
-			importantNotes: "Requires a routineId from get-routines or a prior create response."
-		}),
-		inputSchema: getRoutineSchema,
-		outputSchema: routineOutputSchema,
-		annotations: readOnlyAnnotations("Get Routine")
-	}, wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { routineId } = args;
-		const data = await client.getRoutineById(String(routineId));
-		if (!data || !data.routine) return createStructuredEmptyResponse(`Routine with ID ${routineId} not found`, { routine: null });
-		const routine = formatRoutine(data.routine);
-		return createStructuredJsonResponse(routine, { routine });
-	}, "get-routine"));
-	const createRoutineSchema = {
-		title: z.string().min(1),
-		folderId: z.coerce.number().nullable().optional(),
-		notes: z.string().optional(),
-		exercises: z.preprocess(parseJsonArray, z.array(z.object({
-			exerciseTemplateId: z.string().min(1),
-			supersetId: z.coerce.number().nullable().optional(),
-			restSeconds: z.coerce.number().int().min(0).optional(),
-			notes: z.string().optional(),
-			sets: z.array(z.object({
-				type: setTypeEnum,
-				weight: z.coerce.number().optional(),
-				weightKg: z.coerce.number().optional(),
-				reps: zNullableInt,
-				distance: z.coerce.number().int().optional(),
-				distanceMeters: z.coerce.number().int().optional(),
-				duration: z.coerce.number().int().optional(),
-				durationSeconds: z.coerce.number().int().optional(),
-				customMetric: z.coerce.number().optional(),
-				repRange: zOptionalRepRange
-			}))
-		})))
-	};
-	server.tool("create-routine", describeTool({
+		}))?.routines;
+	}
+};
+const getRoutineSchema = { routineId: nonEmptyId };
+const getRoutineDefinition = {
+	name: "get-routine",
+	description: describeTool({
+		summary: "Read-only. Retrieves one routine and its exercise configuration by ID.",
+		aliases: [
+			"show routine",
+			"fetch workout plan",
+			"routine details"
+		],
+		useCase: "Use when the routineId is known; use get-routines to browse or discover IDs.",
+		importantNotes: "Requires a routineId from get-routines or a prior create response."
+	}),
+	inputSchema: getRoutineSchema,
+	kind: "read",
+	outputSchema: routineResponse.outputSchema,
+	annotations: readOnlyAnnotations("Get Routine"),
+	responseContract: routineResponse,
+	execute: async (runtime, { routineId }) => {
+		return {
+			routine: (await runtime.getClient().getRoutineById(String(routineId)))?.routine,
+			routineId
+		};
+	}
+};
+const routineExercisesSchema = z.preprocess(parseJsonArray, z.array(z.object(routineExerciseShape)));
+const createRoutineSchema = routinePayloadShape;
+const createRoutineDefinition = {
+	name: "create-routine",
+	description: describeTool({
 		summary: "Writes to the Hevy account by creating a new workout routine.",
 		aliases: [
 			"add routine",
@@ -1515,138 +1728,84 @@ function registerRoutineTools(server, hevyClient, wrapHandler = withErrorHandlin
 		],
 		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"), wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { title, folderId, notes, exercises } = args;
-		let usesRepRanges = false;
-		const data = await client.createRoutine({ routine: {
-			title,
-			folder_id: folderId ?? null,
-			notes: notes ?? "",
-			exercises: exercises.map((exercise) => {
-				const sets = exercise.sets.map((set) => {
-					const repRange = buildRepRange(set.repRange);
-					const fixedReps = getFixedRepsFromRepRange(repRange);
-					const reps = typeof set.reps === "number" ? set.reps : fixedReps;
-					return {
-						type: set.type,
-						weight_kg: set.weight ?? set.weightKg ?? null,
-						reps: reps ?? null,
-						distance_meters: set.distance ?? set.distanceMeters ?? null,
-						duration_seconds: set.duration ?? set.durationSeconds ?? null,
-						custom_metric: set.customMetric ?? null,
-						rep_range: repRange
-					};
-				});
-				if (sets.some((set) => set.rep_range != null && getFixedRepsFromRepRange(set.rep_range) === null)) usesRepRanges = true;
-				return {
-					exercise_template_id: exercise.exerciseTemplateId,
-					superset_id: exercise.supersetId ?? null,
-					rest_seconds: exercise.restSeconds ?? null,
-					notes: exercise.notes ?? null,
-					sets
-				};
-			})
-		} });
-		if (!data) return createEmptyResponse("Failed to create routine: Server returned no data");
-		const response = createJsonResponse(formatRoutine(data), {
-			pretty: true,
-			indent: 2
-		});
-		if (usesRepRanges) response.content.push({
-			type: "text",
-			text: repRangeDisplayWarningText
-		});
-		return response;
-	}, "create-routine"));
-	const updateRoutineSchema = {
-		routineId: z.string().min(1),
-		title: z.string().min(1),
-		notes: z.string().optional(),
-		exercises: z.preprocess(parseJsonArray, z.array(z.object({
-			exerciseTemplateId: z.string().min(1),
-			supersetId: z.coerce.number().nullable().optional(),
-			restSeconds: z.coerce.number().int().min(0).optional(),
-			notes: z.string().optional(),
-			sets: z.array(z.object({
-				type: setTypeEnum,
-				weight: z.coerce.number().optional(),
-				weightKg: z.coerce.number().optional(),
-				reps: zNullableInt,
-				distance: z.coerce.number().int().optional(),
-				distanceMeters: z.coerce.number().int().optional(),
-				duration: z.coerce.number().int().optional(),
-				durationSeconds: z.coerce.number().int().optional(),
-				customMetric: z.coerce.number().optional(),
-				repRange: zOptionalRepRange
-			}))
-		})))
-	};
-	server.tool("update-routine", describeTool({
-		summary: "Mutates the Hevy account by replacing an existing routine's content.",
-		aliases: [
-			"edit routine",
-			"revise workout plan",
-			"replace routine exercises"
-		],
-		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"), wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { routineId, title, notes, exercises } = args;
-		let usesRepRanges = false;
-		const data = await client.updateRoutine(routineId, { routine: {
-			title,
-			notes: notes ?? null,
-			exercises: exercises.map((exercise) => {
-				const sets = exercise.sets.map((set) => {
-					const repRange = buildRepRange(set.repRange);
-					const fixedReps = getFixedRepsFromRepRange(repRange);
-					const reps = typeof set.reps === "number" ? set.reps : fixedReps;
-					return {
-						type: set.type,
-						weight_kg: set.weight ?? set.weightKg ?? null,
-						reps: reps ?? null,
-						distance_meters: set.distance ?? set.distanceMeters ?? null,
-						duration_seconds: set.duration ?? set.durationSeconds ?? null,
-						custom_metric: set.customMetric ?? null,
-						...repRange ? { rep_range: repRange } : {}
-					};
-				});
-				if (sets.some((set) => set.rep_range != null && getFixedRepsFromRepRange(set.rep_range) === null)) usesRepRanges = true;
-				return {
-					exercise_template_id: exercise.exerciseTemplateId,
-					superset_id: exercise.supersetId ?? null,
-					rest_seconds: exercise.restSeconds ?? null,
-					notes: exercise.notes ?? null,
-					sets
-				};
-			})
-		} });
-		if (!data) return createEmptyResponse(`Failed to update routine with ID ${routineId}`);
-		const response = createJsonResponse(formatRoutine(data), {
-			pretty: true,
-			indent: 2
-		});
-		if (usesRepRanges) response.content.push({
-			type: "text",
-			text: repRangeDisplayWarningText
-		});
-		return response;
-	}, "update-routine"));
-}
+	}),
+	inputSchema: createRoutineSchema,
+	kind: "write",
+	annotations: createAnnotations("Create Routine"),
+	responseContract: createRoutineResponse,
+	execute: async (runtime, args) => {
+		const { payload, usesRepRanges } = buildRoutinePayload(args, "create");
+		return {
+			routine: await runtime.getClient().createRoutine({ routine: payload }),
+			usesRepRanges
+		};
+	}
+};
+const updateRoutineSchema = {
+	routineId: nonEmptyId,
+	title: z.string().min(1),
+	notes: z.string().optional(),
+	exercises: routineExercisesSchema
+};
+const routineToolDefinitions = [
+	getRoutinesDefinition,
+	getRoutineDefinition,
+	createRoutineDefinition,
+	{
+		name: "update-routine",
+		description: describeTool({
+			summary: "Mutates the Hevy account by replacing an existing routine's content.",
+			aliases: [
+				"edit routine",
+				"revise workout plan",
+				"replace routine exercises"
+			],
+			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."
+		}),
+		inputSchema: updateRoutineSchema,
+		kind: "write",
+		annotations: updateAnnotations("Update Routine"),
+		responseContract: updateRoutineResponse,
+		execute: async (runtime, args) => {
+			const { routineId } = args;
+			const { payload, usesRepRanges } = buildRoutinePayload(args, "update");
+			return {
+				routine: await runtime.getClient().updateRoutine(routineId, { routine: payload }),
+				routineId,
+				usesRepRanges
+			};
+		}
+	}
+];
 //#endregion
 //#region src/tools/templates.ts
-/**
-* Register all exercise template-related tools with the MCP server
-*/
-function registerTemplateTools(server, hevyClient, 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)
-	};
-	server.registerTool("get-exercise-templates", {
+const getExerciseTemplatesSchema = paginationShape({
+	defaultPageSize: 5,
+	maxPageSize: 100
+});
+const getExerciseTemplateSchema = { exerciseTemplateId: nonEmptyId };
+const getExerciseHistorySchema = {
+	exerciseTemplateId: nonEmptyId,
+	startDate: z.string().datetime({ offset: true }).describe("ISO 8601 start date for filtering history").optional(),
+	endDate: z.string().datetime({ offset: true }).describe("ISO 8601 end date for filtering history").optional()
+};
+const createExerciseTemplateSchema = {
+	title: z.string().min(1),
+	exerciseType: exerciseTypeEnum,
+	equipmentCategory: equipmentCategoryEnum,
+	muscleGroup: muscleGroupEnum,
+	otherMuscles: z.array(muscleGroupEnum).default([])
+};
+const searchExerciseTemplatesSchema = {
+	query: z.string().min(1).describe("Case-insensitive substring to match against exercise template titles"),
+	primaryMuscleGroup: muscleGroupEnum.optional().describe("Optional filter to restrict results to a specific primary muscle group"),
+	refresh: z.boolean().optional().default(false).describe("Set to true to invalidate the catalog cache and re-fetch all templates from the API")
+};
+/** Ordered exercise-template tools for composition by the shared server. */
+const templateToolDefinitions = [
+	{
+		name: "get-exercise-templates",
 		description: describeTool({
 			summary: "Read-only. Lists default and custom exercise templates with equipment and muscle metadata.",
 			aliases: [
@@ -1658,20 +1817,20 @@ function registerTemplateTools(server, hevyClient, options = {}) {
 			importantNotes: "Results are paginated; page starts at 1 and pageSize is limited to 100."
 		}),
 		inputSchema: getExerciseTemplatesSchema,
-		outputSchema: exerciseTemplatesOutputSchema,
-		annotations: readOnlyAnnotations("Get Exercise Templates")
-	}, wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { page, pageSize } = args;
-		const templates = (await client.getExerciseTemplates({
-			page,
-			pageSize
-		}))?.exercise_templates?.map((template) => formatExerciseTemplate(template)) || [];
-		if (templates.length === 0) return createStructuredEmptyResponse("No exercise templates found for the specified parameters", { exerciseTemplates: [] });
-		return createStructuredJsonResponse(templates, { exerciseTemplates: templates });
-	}, "get-exercise-templates"));
-	const getExerciseTemplateSchema = { exerciseTemplateId: z.string().min(1) };
-	server.registerTool("get-exercise-template", {
+		outputSchema: exerciseTemplatesResponse.outputSchema,
+		annotations: readOnlyAnnotations("Get Exercise Templates"),
+		kind: "read",
+		responseContract: exerciseTemplatesResponse,
+		execute: async (runtime, args) => {
+			const { page, pageSize } = args;
+			return (await runtime.getClient().getExerciseTemplates({
+				page,
+				pageSize
+			}))?.exercise_templates;
+		}
+	},
+	{
+		name: "get-exercise-template",
 		description: describeTool({
 			summary: "Read-only. Retrieves complete metadata for one exercise template by ID.",
 			aliases: [
@@ -1683,22 +1842,20 @@ function registerTemplateTools(server, hevyClient, options = {}) {
 			importantNotes: "Requires an exerciseTemplateId from a template list, search, routine, or workout."
 		}),
 		inputSchema: getExerciseTemplateSchema,
-		outputSchema: exerciseTemplateOutputSchema,
-		annotations: readOnlyAnnotations("Get Exercise Template")
-	}, wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { exerciseTemplateId } = args;
-		const data = await client.getExerciseTemplate(exerciseTemplateId);
-		if (!data) return createStructuredEmptyResponse(`Exercise template with ID ${exerciseTemplateId} not found`, { exerciseTemplate: null });
-		const template = formatExerciseTemplate(data);
-		return createStructuredJsonResponse(template, { exerciseTemplate: template });
-	}, "get-exercise-template"));
-	const getExerciseHistorySchema = {
-		exerciseTemplateId: z.string().min(1),
-		startDate: z.string().datetime({ offset: true }).describe("ISO 8601 start date for filtering history").optional(),
-		endDate: z.string().datetime({ offset: true }).describe("ISO 8601 end date for filtering history").optional()
-	};
-	server.registerTool("get-exercise-history", {
+		outputSchema: exerciseTemplateResponse.outputSchema,
+		annotations: readOnlyAnnotations("Get Exercise Template"),
+		kind: "read",
+		responseContract: exerciseTemplateResponse,
+		execute: async (runtime, args) => {
+			const { exerciseTemplateId } = args;
+			return {
+				exerciseTemplate: await runtime.getClient().getExerciseTemplate(exerciseTemplateId),
+				exerciseTemplateId
+			};
+		}
+	},
+	{
+		name: "get-exercise-history",
 		description: describeTool({
 			summary: "Read-only. Retrieves past performed sets for one exercise template.",
 			aliases: [
@@ -1710,54 +1867,50 @@ function registerTemplateTools(server, hevyClient, options = {}) {
 			importantNotes: "Requires an exerciseTemplateId. Optional startDate and endDate must be ISO 8601 datetimes with an offset."
 		}),
 		inputSchema: getExerciseHistorySchema,
-		outputSchema: exerciseHistoryOutputSchema,
-		annotations: readOnlyAnnotations("Get Exercise History")
-	}, wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { exerciseTemplateId, startDate, endDate } = args;
-		const history = (await client.getExerciseHistory(exerciseTemplateId, {
-			...startDate ? { start_date: startDate } : {},
-			...endDate ? { end_date: endDate } : {}
-		}))?.exercise_history?.map((entry) => formatExerciseHistoryEntry(entry)) || [];
-		if (history.length === 0) return createStructuredEmptyResponse(`No exercise history found for template ${exerciseTemplateId}`, { exerciseHistory: [] });
-		return createStructuredJsonResponse(history, { exerciseHistory: history });
-	}, "get-exercise-history"));
-	const createExerciseTemplateSchema = {
-		title: z.string().min(1),
-		exerciseType: exerciseTypeEnum,
-		equipmentCategory: equipmentCategoryEnum,
-		muscleGroup: muscleGroupEnum,
-		otherMuscles: z.array(muscleGroupEnum).default([])
-	};
-	server.tool("create-exercise-template", describeTool({
-		summary: "Writes to the Hevy account by creating a custom exercise template.",
-		aliases: [
-			"add custom exercise",
-			"create movement",
-			"define exercise"
-		],
-		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"), wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { title, exerciseType, equipmentCategory, muscleGroup, otherMuscles } = args;
-		return createJsonResponse({
-			id: (await client.createExerciseTemplate({ exercise: {
+		outputSchema: exerciseHistoryResponse.outputSchema,
+		annotations: readOnlyAnnotations("Get Exercise History"),
+		kind: "read",
+		responseContract: exerciseHistoryResponse,
+		execute: async (runtime, args) => {
+			const { exerciseTemplateId, startDate, endDate } = args;
+			return {
+				history: (await runtime.getClient().getExerciseHistory(exerciseTemplateId, {
+					...startDate ? { start_date: startDate } : {},
+					...endDate ? { end_date: endDate } : {}
+				}))?.exercise_history,
+				exerciseTemplateId
+			};
+		}
+	},
+	{
+		name: "create-exercise-template",
+		description: describeTool({
+			summary: "Writes to the Hevy account by creating a custom exercise template.",
+			aliases: [
+				"add custom exercise",
+				"create movement",
+				"define exercise"
+			],
+			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."
+		}),
+		inputSchema: createExerciseTemplateSchema,
+		annotations: createAnnotations("Create Exercise Template"),
+		kind: "write",
+		responseContract: createExerciseTemplateResponse,
+		execute: async (runtime, args) => {
+			const { title, exerciseType, equipmentCategory, muscleGroup, otherMuscles } = args;
+			return await runtime.getClient().createExerciseTemplate({ exercise: {
 				title,
 				exercise_type: exerciseType,
 				equipment_category: equipmentCategory,
 				muscle_group: muscleGroup,
 				other_muscles: otherMuscles
-			} }))?.id,
-			message: "Exercise template created successfully"
-		});
-	}, "create-exercise-template"));
-	const searchExerciseTemplatesSchema = {
-		query: z.string().min(1).describe("Case-insensitive substring to match against exercise template titles"),
-		primaryMuscleGroup: muscleGroupEnum.optional().describe("Optional filter to restrict results to a specific primary muscle group"),
-		refresh: z.boolean().optional().default(false).describe("Set to true to invalidate the catalog cache and re-fetch all templates from the API")
-	};
-	server.registerTool("search-exercise-templates", {
+			} });
+		}
+	},
+	{
+		name: "search-exercise-templates",
 		description: describeTool({
 			summary: "Read-only for the Hevy account. Searches the full exercise template catalog by title substring.",
 			aliases: [
@@ -1769,322 +1922,650 @@ function registerTemplateTools(server, hevyClient, options = {}) {
 			importantNotes: "Matching is case-insensitive. The catalog is cached locally for 5 minutes; refresh:true re-fetches all pages and changes only local cache state."
 		}),
 		inputSchema: searchExerciseTemplatesSchema,
-		outputSchema: exerciseTemplatesOutputSchema,
-		annotations: readOnlyAnnotations("Search Exercise Templates")
-	}, wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { query, primaryMuscleGroup, refresh } = args;
-		const templates = await catalog.get(client, {
-			refresh,
-			onRefreshed: (refreshedCatalog, reason) => {
-				try {
-					logger?.({
-						level: "info",
-						logger: "hevy-cache",
-						data: {
-							message: "Exercise template catalog refreshed",
-							count: refreshedCatalog.length,
-							reason
-						}
-					});
-				} catch (error) {
-					console.error("Failed to emit structured exercise template cache log", createSafeErrorDiagnostic(error));
+		outputSchema: searchExerciseTemplatesResponse.outputSchema,
+		annotations: readOnlyAnnotations("Search Exercise Templates"),
+		kind: "read",
+		responseContract: searchExerciseTemplatesResponse,
+		execute: async (runtime, args) => {
+			runtime.getClient();
+			const { query, primaryMuscleGroup, refresh } = args;
+			const templates = await runtime.catalog.get({
+				refresh,
+				onRefreshed: (refreshedCatalog, reason) => {
+					try {
+						runtime.logger?.({
+							level: "info",
+							logger: "hevy-cache",
+							data: {
+								message: "Exercise template catalog refreshed",
+								count: refreshedCatalog.length,
+								reason
+							}
+						});
+					} catch (error) {
+						console.error("Failed to emit structured exercise template cache log", createSafeErrorDiagnostic(error));
+					}
 				}
-			}
+			});
+			const queryLower = query.toLowerCase();
+			let results = templates.filter((t) => (t.title ?? "").toLowerCase().includes(queryLower));
+			if (primaryMuscleGroup !== void 0) results = results.filter((t) => t.primary_muscle_group === primaryMuscleGroup);
+			return {
+				results,
+				query,
+				primaryMuscleGroup
+			};
+		}
+	}
+];
+const userToolDefinitions = [{
+	name: "get-user-info",
+	description: describeTool({
+		summary: "Read-only. Returns the authenticated account's user ID, display name, and public profile URL.",
+		aliases: [
+			"who am I",
+			"account info",
+			"verify Hevy user"
+		],
+		useCase: "Use to confirm which Hevy account is connected before reading or writing account data.",
+		importantNotes: "Accepts no inputs and reports only the account associated with the configured credentials."
+	}),
+	inputSchema: {},
+	kind: "read",
+	outputSchema: userResponse.outputSchema,
+	annotations: readOnlyAnnotations("Get User Info"),
+	responseContract: userResponse,
+	execute: async (runtime) => {
+		return (await runtime.getClient().getUserInfo())?.data;
+	}
+}];
+//#endregion
+//#region src/tools/routine-discovery.ts
+const routineDiscoverySchema = {
+	query: z.string().min(1).optional().describe("Optional case-insensitive substring to match routine titles."),
+	limit: z.coerce.number().int().min(1).max(100).default(20).describe("Maximum compact routines to return (1-100).")
+};
+async function discoverRoutines(runtime, { query, limit }) {
+	const normalizedQuery = query?.toLocaleLowerCase();
+	const routines = [];
+	let page = 1;
+	let pages = 0;
+	let itemsScanned = 0;
+	const client = runtime.getClient();
+	while (routines.length < limit) {
+		const data = await client.getRoutines({
+			page,
+			pageSize: 10
 		});
-		const queryLower = query.toLowerCase();
-		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);
-		return createStructuredJsonResponse(exerciseTemplates, { exerciseTemplates });
-	}, "search-exercise-templates"));
-}
-//#endregion
-//#region src/tools/user.ts
-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.",
-			aliases: [
-				"who am I",
-				"account info",
-				"verify Hevy user"
-			],
-			useCase: "Use to confirm which Hevy account is connected before reading or writing account data.",
-			importantNotes: "Accepts no inputs and reports only the account associated with the configured credentials."
-		}),
-		inputSchema: {},
-		outputSchema: userOutputSchema,
-		annotations: readOnlyAnnotations("Get User Info")
-	}, 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 });
-	}, "get-user-info"));
+		pages = page;
+		const pageItems = data?.routines ?? [];
+		itemsScanned += pageItems.length;
+		for (const routine of pageItems) {
+			if (normalizedQuery && !routine.title?.toLocaleLowerCase().includes(normalizedQuery)) continue;
+			routines.push(routine);
+			if (routines.length >= limit) break;
+		}
+		const pageCount = data?.page_count;
+		if (typeof pageCount !== "number" || !Number.isSafeInteger(pageCount) || pageCount <= page) break;
+		page += 1;
+	}
+	return {
+		routines: routines.slice(0, limit).map((routine) => ({
+			...routine.id ? { id: routine.id } : {},
+			...routine.title ? { title: routine.title } : {},
+			folderId: routine.folder_id ?? null,
+			...routine.updated_at ? { updatedAt: routine.updated_at } : {},
+			exerciseCount: routine.exercises?.length ?? 0,
+			setCount: routine.exercises?.reduce((total, exercise) => total + (exercise.sets?.length ?? 0), 0) ?? 0
+		})),
+		workflow: {
+			name: "routine-discovery",
+			pagination: { routines: pages },
+			cacheStatus: "not-used",
+			itemsScanned
+		}
+	};
 }
+const routineDiscoveryToolDefinitions = [{
+	name: "search-routines",
+	description: describeTool({
+		summary: "Read-only. Discovers routines by title and returns compact metadata without full set payloads.",
+		aliases: [
+			"find routine",
+			"browse routine names",
+			"compact routine list"
+		],
+		useCase: "Use to find a routine ID or shortlist plans before calling get-routine for full exercise details.",
+		importantNotes: "Search scans routine pages at pageSize 10 and returns only IDs, titles, folder metadata, and exercise/set counts."
+	}),
+	inputSchema: routineDiscoverySchema,
+	outputSchema: compactRoutinesResponse.outputSchema,
+	annotations: readOnlyAnnotations("Search Routines"),
+	kind: "read",
+	responseContract: compactRoutinesResponse,
+	execute: async (runtime, args) => discoverRoutines(runtime, args)
+}];
 //#endregion
-//#region src/tools/workouts.ts
-function formatWorkoutEvent(event) {
-	if (event.type === "updated" && "workout" in event) return {
-		type: "updated",
-		workout: formatWorkout(event.workout)
+//#region src/tools/workflows.ts
+const trainingSummarySchema = { weeks: z.coerce.number().int().min(1).max(12).default(4).describe("Number of recent weeks to summarize (1-12).") };
+const MILLISECONDS_PER_DAY = 1440 * 60 * 1e3;
+function parseUtcDate(value) {
+	const normalized = value.length === 10 ? `${value}T00:00:00.000Z` : value;
+	const timestamp = Date.parse(normalized);
+	return Number.isFinite(timestamp) ? timestamp : void 0;
+}
+async function fetchRecentPages(loader, pageSize, startDate, endDate, getDate) {
+	const items = [];
+	let page = 1;
+	let itemsScanned = 0;
+	const startTimestamp = parseUtcDate(startDate);
+	const endTimestamp = parseUtcDate(endDate);
+	if (startTimestamp === void 0 || endTimestamp === void 0) return {
+		items,
+		pages: 0,
+		itemsScanned
 	};
-	if (event.type === "deleted" && "id" in event) return {
-		type: "deleted",
-		id: event.id,
-		deletedAt: event.deleted_at
+	const endExclusiveTimestamp = endTimestamp + MILLISECONDS_PER_DAY;
+	while (true) {
+		const result = await loader(page, pageSize);
+		itemsScanned += result.items.length;
+		if (result.items.length === 0) break;
+		for (const item of result.items) {
+			const date = getDate(item);
+			const timestamp = date === void 0 ? void 0 : parseUtcDate(date);
+			if (timestamp !== void 0 && timestamp >= startTimestamp && timestamp < endExclusiveTimestamp) items.push(item);
+		}
+		const lastDate = result.items.map(getDate).filter((date) => date !== void 0).at(-1);
+		const lastTimestamp = lastDate === void 0 ? void 0 : parseUtcDate(lastDate);
+		if (lastTimestamp !== void 0 && lastTimestamp < startTimestamp) break;
+		const pageCount = result.pageCount;
+		if (typeof pageCount !== "number" || !Number.isSafeInteger(pageCount) || pageCount <= page) break;
+		page += 1;
+	}
+	return {
+		items,
+		pages: page,
+		itemsScanned
+	};
+}
+function utcDateString(date) {
+	return date.toISOString().slice(0, 10);
+}
+function getPeriod(weeks) {
+	const end = /* @__PURE__ */ new Date();
+	const start = new Date(end);
+	start.setUTCDate(start.getUTCDate() - weeks * 7);
+	return {
+		startDate: utcDateString(start),
+		endDate: utcDateString(end)
+	};
+}
+function durationSeconds(workout) {
+	if (!workout.start_time || !workout.end_time) return null;
+	const duration = new Date(workout.end_time).getTime() - new Date(workout.start_time).getTime();
+	return Number.isFinite(duration) && duration >= 0 ? Math.floor(duration / 1e3) : null;
+}
+function compactSession(workout) {
+	const exercises = workout.exercises ?? [];
+	return {
+		...workout.id ? { id: workout.id } : {},
+		...workout.title ? { title: workout.title } : {},
+		...workout.start_time ? { startTime: workout.start_time } : {},
+		...workout.end_time ? { endTime: workout.end_time } : {},
+		durationSeconds: durationSeconds(workout),
+		exerciseCount: exercises.length,
+		setCount: exercises.reduce((total, exercise) => total + (exercise.sets?.length ?? 0), 0)
 	};
-	throw new Error(`Unsupported workout event type: ${event.type}`);
 }
-/**
-* Register all workout-related tools with the MCP server
-*/
-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)
+function compactMeasurement(measurement) {
+	return {
+		date: measurement.date,
+		weightKg: measurement.weight_kg ?? null,
+		leanMassKg: measurement.lean_mass_kg ?? null,
+		fatPercent: measurement.fat_percent ?? null
 	};
-	server.registerTool("get-workouts", {
-		description: describeTool({
-			summary: "Read-only. Lists workouts from newest to oldest with exercise and timing details.",
-			aliases: [
-				"list workout history",
-				"show recent workouts",
-				"browse logs"
-			],
-			useCase: "Use to browse or page through workout history; use get-workout when a workout ID is already known.",
-			importantNotes: "Results are paginated; page starts at 1 and pageSize is limited to 10."
-		}),
-		inputSchema: getWorkoutsSchema,
-		outputSchema: workoutsOutputSchema,
-		annotations: readOnlyAnnotations("Get Workouts")
-	}, wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { page, pageSize } = args;
-		const workouts = (await client.getWorkouts({
+}
+async function getTrainingSummary(runtime, weeks) {
+	const client = runtime.getClient();
+	const period = getPeriod(weeks);
+	const pageSize = 10;
+	const [workoutPages, measurementPages] = await Promise.all([fetchRecentPages(async (page, pageSize) => {
+		const data = await client.getWorkouts({
 			page,
 			pageSize
-		}))?.workouts?.map((workout) => formatWorkout(workout)) || [];
-		if (workouts.length === 0) return createStructuredEmptyResponse("No workouts found for the specified parameters", { workouts: [] });
-		return createStructuredJsonResponse(workouts, { workouts });
-	}, "get-workouts"));
-	const getWorkoutSchema = { workoutId: z.string().min(1) };
-	server.registerTool("get-workout", {
-		description: describeTool({
-			summary: "Read-only. Retrieves complete details for one workout by its ID.",
-			aliases: [
-				"show workout",
-				"fetch workout details",
-				"open workout log"
-			],
-			useCase: "Use after get-workouts identifies the exact workout; do not use for browsing multiple workouts.",
-			importantNotes: "Requires a workoutId discovered from a workout list, event, or prior create response."
-		}),
-		inputSchema: getWorkoutSchema,
-		outputSchema: workoutOutputSchema,
-		annotations: readOnlyAnnotations("Get Workout")
-	}, wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { workoutId } = args;
-		const data = await client.getWorkout(workoutId);
-		if (!data) return createStructuredEmptyResponse(`Workout with ID ${workoutId} not found`, { workout: null });
-		const workout = formatWorkout(data);
-		return createStructuredJsonResponse(workout, { workout });
-	}, "get-workout"));
-	server.registerTool("get-workout-count", {
-		description: describeTool({
-			summary: "Read-only. Returns the total workout count for the account.",
-			aliases: [
-				"count workouts",
-				"how many workouts",
-				"workout total"
-			],
-			useCase: "Use for totals, statistics, or estimating pages; use get-workouts for actual workout records.",
-			importantNotes: "Returns only a count and accepts no paging or date filters."
-		}),
-		inputSchema: {},
-		outputSchema: workoutCountOutputSchema,
-		annotations: readOnlyAnnotations("Get Workout Count")
-	}, wrapHandler(async () => {
-		const count = (await requireClient(hevyClient).getWorkoutCount())?.workout_count ?? 0;
-		return createStructuredJsonResponse({ count }, { count });
-	}, "get-workout-count"));
-	const getWorkoutEventsSchema = {
-		page: z.coerce.number().int().gte(1).default(1),
-		pageSize: z.coerce.number().int().gte(1).lte(10).default(5),
-		since: z.string().default("1970-01-01T00:00:00Z")
-	};
-	server.registerTool("get-workout-events", {
-		description: describeTool({
-			summary: "Read-only. Lists workout update and delete events since a timestamp, newest first.",
-			aliases: [
-				"sync workout changes",
-				"workout change feed",
-				"deleted workouts"
-			],
-			useCase: "Use to incrementally synchronize a local workout cache; use get-workouts for the current workout list.",
-			importantNotes: "since must be a timestamp string; events are paginated with pageSize at most 10, and the default since value reads from 1970."
-		}),
-		inputSchema: getWorkoutEventsSchema,
-		outputSchema: workoutEventsOutputSchema,
-		annotations: readOnlyAnnotations("Get Workout Events")
-	}, wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { page, pageSize, since } = args;
-		const events = (await client.getWorkoutEvents({
+		});
+		return {
+			items: data?.workouts ?? [],
+			pageCount: data?.page_count
+		};
+	}, pageSize, period.startDate, period.endDate, (workout) => workout.start_time), fetchRecentPages(async (page, pageSize) => {
+		const data = await client.getBodyMeasurements({
 			page,
-			pageSize,
-			since
-		}))?.events?.map(formatWorkoutEvent) || [];
-		if (events.length === 0) return createStructuredEmptyResponse(`No workout events found for the specified parameters since ${since}`, { events: [] });
-		return createStructuredJsonResponse(events, { events });
-	}, "get-workout-events"));
-	const createWorkoutSchema = {
-		title: z.string().min(1),
-		description: z.string().optional().nullable(),
-		startTime: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
-		endTime: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
-		isPrivate: z.boolean().default(false),
-		exercises: z.preprocess(parseJsonArray, z.array(z.object({
-			exerciseTemplateId: z.string().min(1),
-			supersetId: z.coerce.number().nullable().optional(),
-			notes: z.string().optional().nullable(),
-			sets: z.array(z.object({
-				type: setTypeEnum,
-				weight: z.coerce.number().optional().nullable(),
-				weightKg: z.coerce.number().optional().nullable(),
-				reps: z.coerce.number().int().optional().nullable(),
-				distance: z.coerce.number().int().optional().nullable(),
-				distanceMeters: z.coerce.number().int().optional().nullable(),
-				duration: z.coerce.number().int().optional().nullable(),
-				durationSeconds: z.coerce.number().int().optional().nullable(),
-				rpe: z.coerce.number().optional().nullable(),
-				customMetric: z.coerce.number().optional().nullable()
-			}))
-		})))
-	};
-	server.tool("create-workout", describeTool({
-		summary: "Writes to the Hevy account by creating a new workout.",
-		aliases: [
-			"log workout",
-			"add workout",
-			"record training session"
-		],
-		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"), wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { title, description, startTime, endTime, isPrivate, exercises } = args;
-		const requestBody = { workout: {
-			title,
-			description: description ?? null,
-			start_time: startTime,
-			end_time: endTime,
-			is_private: isPrivate,
-			exercises: exercises.map((exercise) => ({
-				exercise_template_id: exercise.exerciseTemplateId,
-				superset_id: exercise.supersetId ?? null,
-				notes: exercise.notes ?? null,
-				sets: exercise.sets.map((set) => ({
-					type: set.type,
-					weight_kg: set.weight ?? set.weightKg ?? null,
-					reps: set.reps ?? null,
-					distance_meters: set.distance ?? set.distanceMeters ?? null,
-					duration_seconds: set.duration ?? set.durationSeconds ?? null,
-					rpe: set.rpe ?? null,
-					custom_metric: set.customMetric ?? null
-				}))
-			}))
-		} };
-		const data = await client.createWorkout(requestBody);
-		if (!data) return createEmptyResponse("Failed to create workout: Server returned no data");
-		return createJsonResponse(formatWorkout(data), {
-			pretty: true,
-			indent: 2
+			pageSize
 		});
-	}, "create-workout"));
-	const updateWorkoutSchema = {
-		workoutId: z.string().min(1),
-		title: z.string().min(1),
-		description: z.string().optional().nullable(),
-		startTime: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
-		endTime: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
-		isPrivate: z.boolean().default(false),
-		exercises: z.preprocess(parseJsonArray, z.array(z.object({
-			exerciseTemplateId: z.string().min(1),
-			supersetId: z.coerce.number().nullable().optional(),
-			notes: z.string().optional().nullable(),
-			sets: z.array(z.object({
-				type: setTypeEnum,
-				weight: z.coerce.number().optional().nullable(),
-				weightKg: z.coerce.number().optional().nullable(),
-				reps: z.coerce.number().int().optional().nullable(),
-				distance: z.coerce.number().int().optional().nullable(),
-				distanceMeters: z.coerce.number().int().optional().nullable(),
-				duration: z.coerce.number().int().optional().nullable(),
-				durationSeconds: z.coerce.number().int().optional().nullable(),
-				rpe: z.coerce.number().optional().nullable(),
-				customMetric: z.coerce.number().optional().nullable()
-			}))
-		})))
+		return {
+			items: data?.body_measurements ?? [],
+			pageCount: data?.page_count
+		};
+	}, pageSize, period.startDate, period.endDate, (measurement) => measurement.date)]);
+	const workouts = workoutPages.items;
+	const sessions = workouts.map(compactSession);
+	const uniqueExerciseTemplateIds = [...new Set(workouts.flatMap((workout) => (workout.exercises ?? []).map((exercise) => exercise.exercise_template_id).filter((id) => Boolean(id))))];
+	const measurements = [...measurementPages.items].sort((a, b) => a.date.localeCompare(b.date));
+	const earliestMeasurement = measurements[0];
+	const latestMeasurement = measurements.at(-1);
+	const earliest = earliestMeasurement ? compactMeasurement(earliestMeasurement) : null;
+	const latest = latestMeasurement ? compactMeasurement(latestMeasurement) : null;
+	const weightChangeKg = latest?.weightKg !== null && latest?.weightKg !== void 0 && earliest?.weightKg !== null && earliest?.weightKg !== void 0 ? latest.weightKg - earliest.weightKg : null;
+	return {
+		period: {
+			...period,
+			weeks
+		},
+		workouts: {
+			count: workouts.length,
+			totalDurationSeconds: sessions.reduce((total, session) => total + (session.durationSeconds ?? 0), 0),
+			exerciseCount: sessions.reduce((total, session) => total + session.exerciseCount, 0),
+			setCount: sessions.reduce((total, session) => total + session.setCount, 0),
+			uniqueExerciseTemplateIds,
+			sessions
+		},
+		bodyMeasurements: {
+			count: measurements.length,
+			latest,
+			earliest,
+			weightChangeKg
+		},
+		workflow: {
+			name: "training-summary",
+			pagination: {
+				workouts: workoutPages.pages,
+				bodyMeasurements: measurementPages.pages
+			},
+			cacheStatus: "not-used",
+			itemsScanned: workoutPages.itemsScanned + measurementPages.itemsScanned
+		}
 	};
-	server.tool("update-workout", describeTool({
-		summary: "Mutates the Hevy account by replacing an existing workout.",
+}
+const workflowToolDefinitions = [{
+	name: "get-training-summary",
+	description: describeTool({
+		summary: "Read-only. Summarizes recent workout activity and body-measurement trends in one call.",
 		aliases: [
-			"edit workout",
-			"correct workout log",
-			"replace workout details"
+			"training progress",
+			"progress summary",
+			"recent training overview"
 		],
-		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"), wrapHandler(async (args) => {
-		const client = requireClient(hevyClient);
-		const { workoutId, title, description, startTime, endTime, isPrivate, exercises } = args;
-		const requestBody = { workout: {
-			title,
-			description: description ?? null,
-			start_time: startTime,
-			end_time: endTime,
-			is_private: isPrivate,
-			exercises: exercises.map((exercise) => ({
-				exercise_template_id: exercise.exerciseTemplateId,
-				superset_id: exercise.supersetId ?? null,
-				notes: exercise.notes ?? null,
-				sets: exercise.sets.map((set) => ({
-					type: set.type,
-					weight_kg: set.weight ?? set.weightKg ?? null,
-					reps: set.reps ?? null,
-					distance_meters: set.distance ?? set.distanceMeters ?? null,
-					duration_seconds: set.duration ?? set.durationSeconds ?? null,
-					rpe: set.rpe ?? null,
-					custom_metric: set.customMetric ?? null
-				}))
-			}))
-		} };
-		const data = await client.updateWorkout(workoutId, requestBody);
-		if (!data) return createEmptyResponse(`Failed to update workout with ID ${workoutId}`);
-		return createJsonResponse(formatWorkout(data), {
-			pretty: true,
-			indent: 2
-		});
-	}, "update-workout-operation"));
-}
+		useCase: "Use for a bounded progress review instead of separately counting and paging through workouts and body measurements.",
+		importantNotes: "The summary covers the most recent 1-12 weeks, returns compact session evidence, and reports the pages and items scanned."
+	}),
+	inputSchema: trainingSummarySchema,
+	outputSchema: trainingSummaryResponse.outputSchema,
+	annotations: readOnlyAnnotations("Get Training Summary"),
+	kind: "read",
+	responseContract: trainingSummaryResponse,
+	execute: async (runtime, args) => getTrainingSummary(runtime, args.weeks)
+}];
+//#endregion
+//#region src/tools/workouts.ts
+const getWorkoutsSchema = paginationShape({
+	defaultPageSize: 5,
+	maxPageSize: 10,
+	integerPage: false
+});
+const getWorkoutSchema = { workoutId: nonEmptyId };
+const getWorkoutEventsSchema = {
+	...paginationShape({
+		defaultPageSize: 5,
+		maxPageSize: 10
+	}),
+	since: z.string().default("1970-01-01T00:00:00Z")
+};
+const createWorkoutSchema = workoutPayloadShape;
+const updateWorkoutSchema = {
+	workoutId: nonEmptyId,
+	...workoutPayloadShape
+};
 //#endregion
 //#region src/tools/register.ts
+const hevyToolDefinitions = [
+	...[
+		{
+			name: "get-workouts",
+			description: describeTool({
+				summary: "Read-only. Lists workouts from newest to oldest with exercise and timing details.",
+				aliases: [
+					"list workout history",
+					"show recent workouts",
+					"browse logs"
+				],
+				useCase: "Use to browse or page through workout history; use get-workout when a workout ID is already known.",
+				importantNotes: "Results are paginated; page starts at 1 and pageSize is limited to 10."
+			}),
+			inputSchema: getWorkoutsSchema,
+			outputSchema: workoutsResponse.outputSchema,
+			annotations: readOnlyAnnotations("Get Workouts"),
+			kind: "read",
+			responseContract: workoutsResponse,
+			execute: async (runtime, args) => {
+				return (await runtime.getClient().getWorkouts({
+					page: args.page,
+					pageSize: args.pageSize
+				}))?.workouts;
+			}
+		},
+		{
+			name: "get-workout",
+			description: describeTool({
+				summary: "Read-only. Retrieves complete details for one workout by its ID.",
+				aliases: [
+					"show workout",
+					"fetch workout details",
+					"open workout log"
+				],
+				useCase: "Use after get-workouts identifies the exact workout; do not use for browsing multiple workouts.",
+				importantNotes: "Requires a workoutId discovered from a workout list, event, or prior create response."
+			}),
+			inputSchema: getWorkoutSchema,
+			outputSchema: workoutResponse.outputSchema,
+			annotations: readOnlyAnnotations("Get Workout"),
+			kind: "read",
+			responseContract: workoutResponse,
+			execute: async (runtime, args) => {
+				return {
+					workout: await runtime.getClient().getWorkout(args.workoutId),
+					workoutId: args.workoutId
+				};
+			}
+		},
+		{
+			name: "get-workout-count",
+			description: describeTool({
+				summary: "Read-only. Returns the total workout count for the account.",
+				aliases: [
+					"count workouts",
+					"how many workouts",
+					"workout total"
+				],
+				useCase: "Use for totals, statistics, or estimating pages; use get-workouts for actual workout records.",
+				importantNotes: "Returns only a count and accepts no paging or date filters."
+			}),
+			inputSchema: {},
+			outputSchema: workoutCountResponse.outputSchema,
+			annotations: readOnlyAnnotations("Get Workout Count"),
+			kind: "read",
+			responseContract: workoutCountResponse,
+			execute: async (runtime) => {
+				return (await runtime.getClient().getWorkoutCount())?.workout_count ?? 0;
+			}
+		},
+		{
+			name: "get-workout-events",
+			description: describeTool({
+				summary: "Read-only. Lists workout update and delete events since a timestamp, newest first.",
+				aliases: [
+					"sync workout changes",
+					"workout change feed",
+					"deleted workouts"
+				],
+				useCase: "Use to incrementally synchronize a local workout cache; use get-workouts for the current workout list.",
+				importantNotes: "since must be a timestamp string; events are paginated with pageSize at most 10, and the default since value reads from 1970."
+			}),
+			inputSchema: getWorkoutEventsSchema,
+			outputSchema: workoutEventsResponse.outputSchema,
+			annotations: readOnlyAnnotations("Get Workout Events"),
+			kind: "read",
+			responseContract: workoutEventsResponse,
+			execute: async (runtime, args) => {
+				return {
+					events: (await runtime.getClient().getWorkoutEvents({
+						page: args.page,
+						pageSize: args.pageSize,
+						since: args.since
+					}))?.events,
+					since: args.since
+				};
+			}
+		},
+		{
+			name: "create-workout",
+			description: describeTool({
+				summary: "Writes to the Hevy account by creating a new workout.",
+				aliases: [
+					"log workout",
+					"add workout",
+					"record training session"
+				],
+				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."
+			}),
+			inputSchema: createWorkoutSchema,
+			annotations: createAnnotations("Create Workout"),
+			kind: "write",
+			responseContract: createWorkoutResponse,
+			execute: async (runtime, args) => {
+				return await runtime.getClient().createWorkout({ workout: buildWorkoutPayload(args) });
+			}
+		},
+		{
+			name: "update-workout",
+			description: describeTool({
+				summary: "Mutates the Hevy account by replacing an existing workout.",
+				aliases: [
+					"edit workout",
+					"correct workout log",
+					"replace workout details"
+				],
+				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."
+			}),
+			inputSchema: updateWorkoutSchema,
+			annotations: updateAnnotations("Update Workout"),
+			kind: "write",
+			responseContract: updateWorkoutResponse,
+			execute: async (runtime, args) => {
+				return {
+					workout: await runtime.getClient().updateWorkout(args.workoutId, { workout: buildWorkoutPayload(args) }),
+					workoutId: args.workoutId
+				};
+			}
+		}
+	],
+	...routineToolDefinitions,
+	...templateToolDefinitions,
+	...folderToolDefinitions,
+	...bodyMeasurementToolDefinitions,
+	...userToolDefinitions,
+	...workflowToolDefinitions,
+	...routineDiscoveryToolDefinitions
+];
 /** 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
+function registerHevyTools(server, runtime) {
+	for (const definition of hevyToolDefinitions) registerToolDefinition(server, runtime, definition);
+}
+//#endregion
+//#region src/utils/error-handler.ts
+/**
+* Centralized error handling utility for MCP tools
+*/
+/**
+* Create a standardized error response for MCP tools
+*
+* @param error - The error object or message
+* @param context - Optional context information about where the error occurred
+* @returns A formatted MCP tool response with error information
+*/
+function createErrorResponse(error, context) {
+	const policy = resolveErrorPolicy(error, "The request failed unexpectedly. Please try again.", HEVY_CLIENT_NOT_INITIALIZED_ERROR);
+	const { diagnostic } = policy;
+	const axiosErrorContext = diagnostic.status !== void 0 || diagnostic.method !== void 0 || diagnostic.endpoint !== void 0 ? {
+		status: diagnostic.status,
+		method: diagnostic.method,
+		url: diagnostic.endpoint
+	} : null;
+	const errorContext = {
+		sourceContext: context,
+		originalErrorMessage: `${diagnostic.category} occurred`,
+		errorCode: diagnostic.code,
+		errorType: policy.type,
+		axios: axiosErrorContext ?? void 0
+	};
+	const formattedMessage = `${context ? `[${context}] ` : ""}Error: ${policy.message}`;
+	console.error("MCP tool failure", diagnostic);
+	return {
+		content: [{
+			type: "text",
+			text: formattedMessage
+		}],
+		isError: true,
+		errorContext
+	};
+}
+/**
+* Wrap an async function with standardized error handling
+*
+* This function preserves the parameter types of the wrapped function while
+* providing error handling. The returned function accepts Record<string, unknown>
+* (as required by MCP SDK) but internally casts to the original parameter type.
+*
+* @param fn - The async function to wrap
+* @param context - Context information for error messages
+* @returns A function that catches errors and returns standardized error responses
+*/
+function withErrorHandling(fn, context, onError) {
+	return async (rawArgs) => {
+		const args = rawArgs ?? {};
+		try {
+			return await fn(args);
+		} catch (error) {
+			try {
+				onError?.(error, context, Object.keys(args).length);
+			} catch {
+				console.error("MCP error observer failure", { category: "ObserverError" });
+			}
+			return createErrorResponse(error, context);
+		}
+	};
+}
+//#endregion
+//#region src/utils/cache.ts
+/**
+* Shared in-memory cache for async fetches with TTL, LRU eviction,
+* in-flight de-duplication, and explicit refresh/invalidation support.
+*/
+var AsyncTtlCache = class {
+	ttlMs;
+	maxSize;
+	now;
+	entries = /* @__PURE__ */ new Map();
+	inFlight = /* @__PURE__ */ new Map();
+	requestCounter = 0;
+	constructor(options, now = Date.now) {
+		const { ttlMs, maxSize } = options;
+		if (ttlMs <= 0) throw new Error("Cache ttlMs must be greater than 0.");
+		if (maxSize <= 0) throw new Error("Cache maxSize must be greater than 0.");
+		this.ttlMs = ttlMs;
+		this.maxSize = maxSize;
+		this.now = now;
+	}
+	async getOrFetch(key, fetcher, options = {}) {
+		const { refresh = false } = options;
+		if (refresh) this.invalidate(key);
+		else {
+			const cachedEntry = this.entries.get(key);
+			if (cachedEntry !== void 0) {
+				if (cachedEntry.expiresAt > this.now()) {
+					this.markAsRecentlyUsed(key, cachedEntry);
+					return cachedEntry.value;
+				}
+				this.entries.delete(key);
+			}
+			const inFlightEntry = this.inFlight.get(key);
+			if (inFlightEntry !== void 0) return inFlightEntry.promise;
+		}
+		const requestId = ++this.requestCounter;
+		const request = (async () => {
+			try {
+				const value = await fetcher();
+				if (this.isCurrentRequest(key, requestId)) this.setValue(key, value);
+				return value;
+			} finally {
+				if (this.inFlight.get(key)?.requestId === requestId) this.inFlight.delete(key);
+			}
+		})();
+		this.inFlight.set(key, {
+			promise: request,
+			requestId
+		});
+		return request;
+	}
+	invalidate(key) {
+		this.entries.delete(key);
+		this.inFlight.delete(key);
+	}
+	clear() {
+		this.entries.clear();
+		this.inFlight.clear();
+	}
+	get size() {
+		return this.entries.size;
+	}
+	isCurrentRequest(key, requestId) {
+		return this.inFlight.get(key)?.requestId === requestId;
+	}
+	markAsRecentlyUsed(key, entry) {
+		this.entries.delete(key);
+		this.entries.set(key, entry);
+	}
+	setValue(key, value) {
+		this.entries.delete(key);
+		this.entries.set(key, {
+			value,
+			expiresAt: this.now() + this.ttlMs
+		});
+		this.evictLeastRecentlyUsed();
+	}
+	evictLeastRecentlyUsed() {
+		while (this.entries.size > this.maxSize) {
+			const oldestKey = this.entries.keys().next().value;
+			if (oldestKey === void 0) return;
+			this.entries.delete(oldestKey);
+		}
+	}
+};
+//#endregion
+//#region src/utils/exercise-template-catalog.ts
+const EXERCISE_TEMPLATE_CATALOG_CACHE_KEY = "exercise-template-catalog";
+const EXERCISE_TEMPLATE_CATALOG_CACHE_TTL_MS = 300 * 1e3;
+const EXERCISE_TEMPLATE_CATALOG_CACHE_MAX_SIZE = 1;
+/** Create a cache owned by one MCP server/request lifecycle. */
+function createExerciseTemplateCatalog(hevyClient) {
+	const cache = new AsyncTtlCache({
+		ttlMs: EXERCISE_TEMPLATE_CATALOG_CACHE_TTL_MS,
+		maxSize: EXERCISE_TEMPLATE_CATALOG_CACHE_MAX_SIZE
 	});
-	registerFolderTools(server, hevyClient, wrapHandler);
-	registerBodyMeasurementTools(server, hevyClient, wrapHandler);
-	registerUserTools(server, hevyClient, wrapHandler);
+	return {
+		get(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 fetchAllPages(async (page, pageSize) => {
+					const data = await hevyClient.getExerciseTemplates({
+						page,
+						pageSize
+					});
+					return {
+						items: data?.exercise_templates ?? [],
+						pageCount: data?.page_count
+					};
+				}, 100);
+				options.onRefreshed?.(catalog, reason);
+				return catalog;
+			}, options);
+		},
+		reset() {
+			cache.clear();
+		}
+	};
 }
 //#endregion
 //#region src/generated/.kubb/fetch.ts
@@ -2709,9 +3190,6 @@ const SAFE_DYNAMIC_ENDPOINTS = [
 	["/v1/routines/", "/v1/routines/:routineId"],
 	["/v1/workouts/", "/v1/workouts/:workoutId"]
 ];
-function wrapApi(fn) {
-	return fn;
-}
 function normalizePositiveInteger(value, fallback) {
 	return value === void 0 || !Number.isFinite(value) || value <= 0 ? fallback : Math.max(1, Math.floor(value));
 }
@@ -2910,28 +3388,28 @@ function createClient$1(apiKey, baseUrl = "https://api.hevyapp.com", options = {
 	const headers = { "api-key": apiKey };
 	const client = createNativeClient(apiKey, baseUrl, options);
 	return {
-		getWorkouts: (params) => wrapApi(getV1Workouts)(headers, params, { client }),
-		getWorkout: (workoutId) => wrapApi(getV1WorkoutsWorkoutid)(workoutId, headers, { client }),
-		createWorkout: (data) => wrapApi(postV1Workouts)(data, headers, { client }),
-		updateWorkout: (workoutId, data) => wrapApi(putV1WorkoutsWorkoutid)(workoutId, data, headers, { client }),
-		getWorkoutCount: () => wrapApi(getV1WorkoutsCount)(headers, { client }),
-		getWorkoutEvents: (params) => wrapApi(getV1WorkoutsEvents)(headers, params, { client }),
-		getRoutines: (params) => wrapApi(getV1Routines)(headers, params, { client }),
-		getRoutineById: (routineId) => wrapApi(getV1RoutinesRoutineid)(routineId, headers, { client }),
-		createRoutine: (data) => wrapApi(postV1Routines)(data, headers, { client }),
-		updateRoutine: (routineId, data) => wrapApi(putV1RoutinesRoutineid)(routineId, data, headers, { client }),
-		getExerciseTemplates: (params) => wrapApi(getV1ExerciseTemplates)(headers, params, { client }),
-		getExerciseTemplate: (templateId) => wrapApi(getV1ExerciseTemplatesExercisetemplateid)(templateId, headers, { client }),
-		getExerciseHistory: (exerciseTemplateId, params) => wrapApi(getV1ExerciseHistoryExercisetemplateid)(exerciseTemplateId, headers, params, { client }),
-		createExerciseTemplate: (data) => wrapApi(postV1ExerciseTemplates)(data, headers, { client }),
-		getRoutineFolders: (params) => wrapApi(getV1RoutineFolders)(headers, params, { client }),
-		createRoutineFolder: (data) => wrapApi(postV1RoutineFolders)(data, headers, { client }),
-		getRoutineFolder: (folderId) => wrapApi(getV1RoutineFoldersFolderid)(folderId, headers, { client }),
-		getBodyMeasurements: (params) => wrapApi(getV1BodyMeasurements)(headers, params, { client }),
-		getBodyMeasurement: (date) => wrapApi(getV1BodyMeasurementsDate)(date, headers, { client }),
-		createBodyMeasurement: (data) => wrapApi(postV1BodyMeasurements)(data, headers, { client }),
-		updateBodyMeasurement: (date, data) => wrapApi(putV1BodyMeasurementsDate)(date, data, headers, { client }),
-		getUserInfo: (config = {}) => wrapApi(getV1UserInfo)(headers, {
+		getWorkouts: (params) => getV1Workouts(headers, params, { client }),
+		getWorkout: (workoutId) => getV1WorkoutsWorkoutid(workoutId, headers, { client }),
+		createWorkout: (data) => postV1Workouts(data, headers, { client }),
+		updateWorkout: (workoutId, data) => putV1WorkoutsWorkoutid(workoutId, data, headers, { client }),
+		getWorkoutCount: () => getV1WorkoutsCount(headers, { client }),
+		getWorkoutEvents: (params) => getV1WorkoutsEvents(headers, params, { client }),
+		getRoutines: (params) => getV1Routines(headers, params, { client }),
+		getRoutineById: (routineId) => getV1RoutinesRoutineid(routineId, headers, { client }),
+		createRoutine: (data) => postV1Routines(data, headers, { client }),
+		updateRoutine: (routineId, data) => putV1RoutinesRoutineid(routineId, data, headers, { client }),
+		getExerciseTemplates: (params) => getV1ExerciseTemplates(headers, params, { client }),
+		getExerciseTemplate: (templateId) => getV1ExerciseTemplatesExercisetemplateid(templateId, headers, { client }),
+		getExerciseHistory: (exerciseTemplateId, params) => getV1ExerciseHistoryExercisetemplateid(exerciseTemplateId, headers, params, { client }),
+		createExerciseTemplate: (data) => postV1ExerciseTemplates(data, headers, { client }),
+		getRoutineFolders: (params) => getV1RoutineFolders(headers, params, { client }),
+		createRoutineFolder: (data) => postV1RoutineFolders(data, headers, { client }),
+		getRoutineFolder: (folderId) => getV1RoutineFoldersFolderid(folderId, headers, { client }),
+		getBodyMeasurements: (params) => getV1BodyMeasurements(headers, params, { client }),
+		getBodyMeasurement: (date) => getV1BodyMeasurementsDate(date, headers, { client }),
+		createBodyMeasurement: (data) => postV1BodyMeasurements(data, headers, { client }),
+		updateBodyMeasurement: (date, data) => putV1BodyMeasurementsDate(date, data, headers, { client }),
+		getUserInfo: (config = {}) => getV1UserInfo(headers, {
 			...config,
 			client
 		})
@@ -2966,6 +3444,17 @@ function createMcpClientLogger(server) {
 	};
 }
 //#endregion
+//#region src/tools/tool-runtime.ts
+function createToolRuntime({ client, catalog, logger, wrapHandler = withErrorHandling }) {
+	return {
+		client,
+		catalog,
+		logger,
+		wrapHandler,
+		getClient: () => requireClient(client)
+	};
+}
+//#endregion
 //#region src/shared-server.ts
 function createToolCountingServer(server) {
 	let count = 0;
@@ -3004,17 +3493,17 @@ function createSharedMcpServer(options) {
 		...options.clientOptions,
 		logger
 	});
-	const wrapHandler = options.wrapHandler ?? withErrorHandling;
-	const catalog = createExerciseTemplateCatalog();
-	const counting = createToolCountingServer(server);
-	registerHevyTools(counting.server, hevyClient, {
-		catalog,
+	const runtime = createToolRuntime({
+		client: hevyClient,
+		catalog: createExerciseTemplateCatalog(hevyClient),
 		logger,
-		wrapHandler
+		wrapHandler: options.wrapHandler ?? withErrorHandling
 	});
+	const counting = createToolCountingServer(server);
+	registerHevyTools(counting.server, runtime);
 	options.onToolsRegistered?.(counting.getCount());
 	registerWorkoutPrompts(server);
-	registerHevyResources(server, hevyClient, catalog);
+	registerHevyResources(server, runtime);
 	return server;
 }
 //#endregion
@@ -3264,6 +3753,28 @@ function extractSafeArgs(args) {
 	}
 	return attributes;
 }
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function getWorkflowTelemetry(result) {
+	const structuredContent = result.structuredContent;
+	if (!isRecord(structuredContent)) return null;
+	const workflow = structuredContent.workflow;
+	if (!isRecord(workflow)) return null;
+	const name = workflow.name;
+	const paginationValue = workflow.pagination;
+	const cacheStatus = workflow.cacheStatus;
+	const itemsScanned = workflow.itemsScanned;
+	if (typeof name !== "string" || !isRecord(paginationValue) || typeof cacheStatus !== "string" || typeof itemsScanned !== "number" || !Number.isSafeInteger(itemsScanned) || itemsScanned < 0) return null;
+	const pagination = {};
+	for (const [key, value] of Object.entries(paginationValue)) if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) pagination[key] = value;
+	return {
+		name,
+		pagination,
+		cacheStatus,
+		itemsScanned
+	};
+}
 /**
 * Wrap an MCP tool handler with its existing OpenTelemetry span and metrics.
 */
@@ -3283,6 +3794,7 @@ function withTelemetry(fn, context) {
 		const whitelistedKeys = Object.keys(safeArgs).map((key) => key.replace("mcp.tool.args.", ""));
 		return tracer.startActiveSpan(`mcp.tool.${context}`, { attributes: {
 			"mcp.tool.name": context,
+			"workflow.name": context,
 			"mcp.tool.args.key_count": argumentKeyCount,
 			"mcp.tool.args.keys": whitelistedKeys.join(","),
 			...userId ? { "user.id": userId } : {},
@@ -3298,11 +3810,19 @@ function withTelemetry(fn, context) {
 					const textLength = result.content.reduce((sum, item) => sum + (item.text?.length ?? 0), 0);
 					span.setAttribute("mcp.tool.result.text_length", textLength);
 				}
+				const workflow = getWorkflowTelemetry(result);
+				if (workflow) {
+					span.setAttribute("workflow.name", workflow.name);
+					span.setAttribute("workflow.cache_status", workflow.cacheStatus);
+					span.setAttribute("workflow.items_scanned", workflow.itemsScanned);
+					for (const [resource, pageCount] of Object.entries(workflow.pagination)) span.setAttribute(`workflow.pagination.${resource}.pages`, pageCount);
+				}
 				return result;
 			} catch (error) {
 				isError = true;
 				span.setStatus({ code: SpanStatusCode.ERROR });
-				const diagnostic = createSafeErrorDiagnostic(error);
+				const policy = resolveErrorPolicy(error, "");
+				const { diagnostic } = policy;
 				span.addEvent("mcp.tool.failure", {
 					"error.category": diagnostic.category,
 					...diagnostic.code ? { "error.code": diagnostic.code } : {},
@@ -3310,7 +3830,7 @@ function withTelemetry(fn, context) {
 					...diagnostic.method ? { "http.method": diagnostic.method } : {},
 					...diagnostic.endpoint ? { "hevy.api.endpoint": diagnostic.endpoint } : {}
 				});
-				const errorType = determineErrorType(error, `${diagnostic.category} occurred`);
+				const errorType = policy.type;
 				span.setAttribute("error.type", errorType);
 				toolErrors.add(1, {
 					tool_name: context,
@@ -3334,7 +3854,7 @@ function withTelemetry(fn, context) {
 */
 function withObservability(fn, context) {
 	return withErrorHandling(withTelemetry(fn, context), context, (error, _toolContext, argumentKeyCount) => {
-		const diagnostic = createSafeErrorDiagnostic(error);
+		const { diagnostic } = resolveErrorPolicy(error, "");
 		Sentry.withScope((scope) => {
 			scope.setTag("error.category", diagnostic.category);
 			if (diagnostic.code) scope.setTag("error.code", diagnostic.code);
@@ -3810,4 +4330,4 @@ async function runServer() {
 //#endregion
 export { createSafeErrorDiagnostic as i, createServer as n, runServer as r, configSchema as t };
 
-//# sourceMappingURL=src-CkkrTrrg.mjs.map
+//# sourceMappingURL=src-D1O3O9f2.mjs.map