hevy-mcp 4.1.3 → 5.0.0

package/dist/{src-CBiQ6f-q.mjs → src-BUmpaxmH.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@4.1.3" };
+		e.SENTRY_RELEASE = { id: "hevy-mcp@5.0.0" };
 		var n = new e.Error().stack;
-		n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "112c763b-1652-4fb5-8237-94b6a8ef1122", e._sentryDebugIdIdentifier = "sentry-dbid-112c763b-1652-4fb5-8237-94b6a8ef1122");
+		n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "8ea46bdf-fa98-4e73-b4d5-a25044e016df", e._sentryDebugIdIdentifier = "sentry-dbid-8ea46bdf-fa98-4e73-b4d5-a25044e016df");
 	} catch (e) {}
 })();
 import { createHmac, randomUUID, timingSafeEqual } from "node:crypto";
@@ -80,11 +80,11 @@ function sanitizeSentryMcpSpan(span) {
 * OTel Collector → Honeycomb: performance traces, metrics
 */
 const name$1 = "hevy-mcp";
-const version$1 = "4.1.3";
+const version$1 = "5.0.0";
 const telemetryEnabled = process.env.HEVY_MCP_TELEMETRY !== "0";
 const collectorToken = "NH9vOela-HYreQxAbJa68cjEmORoEKM57EvneUDVcOo";
 const COLLECTOR_ENDPOINT = "https://otel.chrisdoc.dev/v1";
-const sentryRelease = process.env.SENTRY_RELEASE ?? `hevy-mcp@4.1.3`;
+const sentryRelease = process.env.SENTRY_RELEASE ?? `hevy-mcp@5.0.0`;
 const resource = resourceFromAttributes({
 	"service.name": name$1,
 	"service.version": version$1
@@ -226,8 +226,8 @@ const repRangeShape = {
 function optionalRepRangeSchema(schema) {
 	return z.preprocess((value) => value === null ? void 0 : value, schema);
 }
-const zOptionalRepRange = optionalRepRangeSchema(z.object(repRangeShape).optional());
-optionalRepRangeSchema(z.object(repRangeShape).strict().optional());
+optionalRepRangeSchema(z.object(repRangeShape).optional());
+const zStrictOptionalRepRange = optionalRepRangeSchema(z.object(repRangeShape).strict().optional());
 const setTypeEnum = z.enum([
 	"warmup",
 	"normal",
@@ -1468,8 +1468,8 @@ function withPromptObservation(name, observer, handler) {
 			scope = memoizeObservationScope(observer?.start({
 				name,
 				kind: "prompt",
-				argumentKeys: Object.keys(args).filter((key) => key === "routineId"),
-				argumentPresence: args.routineId ? { routineId: true } : {},
+				argumentKeys: Object.keys(args).filter((key) => key === "routine_id"),
+				argumentPresence: args.routine_id ? { routine_id: true } : {},
 				argumentKeyCountBucket: bucketCount(Object.keys(args).length)
 			}));
 		} catch {
@@ -1524,22 +1524,22 @@ function registerWorkoutPrompts(server, observer) {
 		title: "Create Workout From Routine",
 		description: "Create a completed workout from an existing routine.",
 		argsSchema: z.object({
-			routineId: z.string().min(1).optional().describe("Routine ID to use as a guide."),
-			startTime: utcSecondTimestamp.optional().describe("Workout start time in UTC as YYYY-MM-DDTHH:mm:ssZ.")
+			routine_id: z.string().min(1).optional().describe("Routine ID to use as a guide."),
+			start_time: utcSecondTimestamp.optional().describe("Workout start time in UTC as YYYY-MM-DDTHH:mm:ssZ.")
 		})
-	}, withPromptObservation("create-workout-from-routine", observer, ({ routineId, startTime }) => ({ messages: [{
+	}, withPromptObservation("create-workout-from-routine", observer, ({ routine_id, start_time }) => ({ messages: [{
 		role: "user",
 		content: {
 			type: "text",
-			text: routineId && startTime ? [
-				`Create a workout from routine ${routineId}, starting at ${startTime}.`,
-				"First call get-routine with the routineId and map supported plan fields: routine title to workout title, plus each exerciseTemplateId, supersetId, exercise notes, and set type.",
-				"Do not copy routine-only restSeconds or repRange fields into create-workout.",
-				"Before calling create-workout, confirm or collect the user's actual completed set data for every set, including applicable weight, reps, distance, duration, RPE, or custom metric values.",
-				"Also collect the required endTime in strict UTC YYYY-MM-DDTHH:mm:ssZ format and confirm any other missing required workout fields.",
-				"Never invent completion data. If the actual results or endTime are unavailable, ask the user for them instead of creating the workout.",
+			text: routine_id && start_time ? [
+				`Create a workout from routine ${routine_id}, starting at ${start_time}.`,
+				["First call get-routine with the routine_id and map supported plan fields:", "routine title to workout title, plus each exercise_template_id, superset_id, exercise notes, and set type."].join(" "),
+				["Do not copy routine-only rest_seconds or rep_range fields into", "create-workout."].join(" "),
+				["Before calling create-workout, confirm or collect the user's actual completed set data for every set,", "including applicable weight_kg, reps, distance_meters, duration_seconds, rpe, or custom_metric values."].join(" "),
+				["Also collect the required end_time in strict UTC YYYY-MM-DDTHH:mm:ssZ format and confirm", "any other missing required workout fields."].join(" "),
+				["Never invent completion data. If the actual results or end_time are unavailable, ask the user for them", "instead of creating the workout."].join(" "),
 				"Once confirmed, call create-workout with only fields supported by that tool."
-			].join("\n") : "Provide a routineId and startTime to generate the full prompt."
+			].join("\n") : "Provide a routine_id and start_time to generate the full prompt."
 		}
 	}] })));
 }
@@ -1845,7 +1845,7 @@ const getV1WorkoutsWorkoutid200Schema = z$1.lazy(() => workoutSchema);
 z$1.any();
 z$1.lazy(() => getV1WorkoutsWorkoutid200Schema);
 //#endregion
-//#region ../core/src/utils/response-formatter.ts
+//#region ../core/src/utils/response-contracts.ts
 function jsonText(data) {
 	return JSON.stringify(data, null, 2) ?? "null";
 }
@@ -1883,146 +1883,150 @@ function defineJsonResponseContract(present, telemetry) {
 function respond(contract, data) {
 	return contract.render(data);
 }
-const optionalNullableNumber = z.number().nullable().optional();
+const optionalNumber = z.number().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
+	weight_kg: optionalNumber,
+	reps: optionalNumber,
+	distance_meters: optionalNumber,
+	duration_seconds: optionalNumber,
+	rpe: optionalNumber,
+	custom_metric: optionalNumber
 });
 const formattedWorkoutExerciseSchema = z.object({
 	index: z.number().optional(),
-	name: z.string().optional(),
-	exerciseTemplateId: z.string().optional(),
-	notes: z.string().nullable().optional(),
-	supersetsId: optionalNullableNumber,
+	title: z.string().optional(),
+	exercise_template_id: z.string().optional(),
+	notes: z.string().optional(),
+	supersets_id: optionalNumber,
 	sets: z.array(formattedWorkoutSetSchema).optional()
 });
 const formattedWorkoutSchema = z.object({
 	id: z.string().optional(),
+	routine_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(),
+	description: z.string().optional(),
+	start_time: z.string().optional(),
+	end_time: z.string().optional(),
+	created_at: z.string().optional(),
+	updated_at: 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
+	weight_kg: optionalNumber,
+	reps: optionalNumber,
+	distance_meters: optionalNumber,
+	duration_seconds: optionalNumber,
+	custom_metric: optionalNumber,
+	rep_range: z.object({
+		start: z.number().optional(),
+		end: z.number().optional()
+	}).optional(),
+	rpe: optionalNumber
 });
 const formattedRoutineExerciseSchema = z.object({
-	name: z.string().optional(),
+	title: 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(),
+	exercise_template_id: z.string().optional(),
+	notes: z.string().optional(),
+	supersets_id: optionalNumber,
+	rest_seconds: z.string().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(),
+	folder_id: z.number().optional(),
+	created_at: z.string().optional(),
+	updated_at: 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()
+	created_at: z.string().optional(),
+	updated_at: 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()
+	primary_muscle_group: z.string().optional(),
+	secondary_muscle_groups: z.array(z.string()).optional(),
+	is_custom: 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()
+	workout_id: z.string().optional(),
+	workout_title: z.string().optional(),
+	workout_start_time: z.string().optional(),
+	workout_end_time: z.string().optional(),
+	exercise_template_id: z.string().optional(),
+	weight_kg: optionalNumber,
+	reps: optionalNumber,
+	distance_meters: optionalNumber,
+	duration_seconds: optionalNumber,
+	rpe: optionalNumber,
+	custom_metric: optionalNumber,
+	set_type: 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()
+	weight_kg: optionalNumber,
+	lean_mass_kg: optionalNumber,
+	fat_percent: optionalNumber,
+	neck_cm: optionalNumber,
+	shoulder_cm: optionalNumber,
+	chest_cm: optionalNumber,
+	left_bicep_cm: optionalNumber,
+	right_bicep_cm: optionalNumber,
+	left_forearm_cm: optionalNumber,
+	right_forearm_cm: optionalNumber,
+	abdomen: optionalNumber,
+	waist: optionalNumber,
+	hips: optionalNumber,
+	left_thigh_cm: optionalNumber,
+	right_thigh_cm: optionalNumber,
+	left_calf_cm: optionalNumber,
+	right_calf_cm: optionalNumber
 });
-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 scanSchema = z.object({
+	pages: z.record(z.string(), z.number().int().nonnegative()),
+	items: 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()
+	start_time: z.string().optional(),
+	end_time: z.string().optional(),
+	duration_seconds: z.number().int().nonnegative().optional(),
+	exercise_count: z.number().int().nonnegative(),
+	set_count: 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()
+	folder_id: z.number().optional(),
+	updated_at: z.string().optional(),
+	exercise_count: z.number().int().nonnegative(),
+	set_count: z.number().int().nonnegative()
+});
+const formattedWorkoutSummarySchema = z.object({
+	id: z.string().optional(),
+	title: z.string().optional(),
+	start_time: z.string().optional(),
+	end_time: z.string().optional(),
+	duration: z.string(),
+	exercise_count: z.number().int().nonnegative(),
+	set_count: z.number().int().nonnegative()
 });
 const paginationOutputSchema = {
 	page: z.number().int().positive(),
-	pageCount: z.number().int().nonnegative().optional(),
-	hasNextPage: z.boolean().optional()
+	page_count: z.number().int().nonnegative().optional(),
+	has_next_page: z.boolean().optional()
 };
 function normalizePaginatedInput(data) {
 	if (data === void 0) return {
@@ -2036,11 +2040,11 @@ function normalizePaginatedInput(data) {
 	};
 }
 const workoutsOutputSchema = {
-	workouts: z.array(formattedWorkoutSchema),
+	workouts: z.array(formattedWorkoutSummarySchema),
 	...paginationOutputSchema
 };
 const workoutOutputSchema = { workout: formattedWorkoutSchema.nullable() };
-const workoutCountOutputSchema = { count: z.number().int() };
+const workoutCountOutputSchema = { workout_count: z.number().int() };
 const formattedUpdatedWorkoutSchema = z.object({
 	type: z.literal("updated"),
 	workout: formattedWorkoutSchema
@@ -2048,70 +2052,70 @@ const formattedUpdatedWorkoutSchema = z.object({
 const formattedDeletedWorkoutSchema = z.object({
 	type: z.literal("deleted"),
 	id: z.string(),
-	deletedAt: z.string().optional()
+	deleted_at: z.string().optional()
 });
 const workoutEventsOutputSchema = {
 	events: z.array(z.union([formattedUpdatedWorkoutSchema, formattedDeletedWorkoutSchema])),
 	...paginationOutputSchema
 };
 const routinesOutputSchema = {
-	routines: z.array(formattedRoutineSchema),
+	routines: z.array(compactRoutineSchema),
 	...paginationOutputSchema
 };
 const routineOutputSchema = { routine: formattedRoutineSchema.nullable() };
 const exerciseTemplatesOutputSchema = {
-	exerciseTemplates: z.array(formattedExerciseTemplateSchema),
+	exercise_templates: z.array(formattedExerciseTemplateSchema),
 	...paginationOutputSchema
 };
-const exerciseTemplateSearchOutputSchema = { exerciseTemplates: z.array(formattedExerciseTemplateSchema) };
-const exerciseTemplateOutputSchema = { exerciseTemplate: formattedExerciseTemplateSchema.nullable() };
-const exerciseHistoryOutputSchema = { exerciseHistory: z.array(formattedExerciseHistoryEntrySchema) };
+const exerciseTemplateSearchOutputSchema = { exercise_templates: z.array(formattedExerciseTemplateSchema) };
+const exerciseTemplateOutputSchema = { exercise_template: formattedExerciseTemplateSchema.nullable() };
+const exerciseHistoryOutputSchema = { exercise_history: z.array(formattedExerciseHistoryEntrySchema) };
 const routineFoldersOutputSchema = {
-	routineFolders: z.array(formattedRoutineFolderSchema),
+	routine_folders: z.array(formattedRoutineFolderSchema),
 	...paginationOutputSchema
 };
-const routineFolderOutputSchema = { routineFolder: formattedRoutineFolderSchema.nullable() };
+const routineFolderOutputSchema = { routine_folder: formattedRoutineFolderSchema.nullable() };
 const bodyMeasurementsOutputSchema = {
-	bodyMeasurements: z.array(formattedBodyMeasurementSchema),
+	body_measurements: z.array(formattedBodyMeasurementSchema),
 	...paginationOutputSchema
 };
-const bodyMeasurementOutputSchema = { bodyMeasurement: formattedBodyMeasurementSchema.nullable() };
+const bodyMeasurementOutputSchema = { body_measurement: formattedBodyMeasurementSchema.nullable() };
 const userOutputSchema = { user: userInfoSchema.nullable() };
 const trainingSummaryOutputSchema = {
 	period: z.object({
-		startDate: z.string(),
-		endDate: z.string(),
+		start_date: z.string(),
+		end_date: 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()),
+		total_duration_seconds: z.number().int().nonnegative(),
+		exercise_count: z.number().int().nonnegative(),
+		set_count: z.number().int().nonnegative(),
+		unique_exercise_template_ids: z.array(z.string()),
 		sessions: z.array(trainingSummarySessionSchema)
 	}),
-	bodyMeasurements: z.object({
+	body_measurements: 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(),
+			weight_kg: optionalNumber,
+			lean_mass_kg: optionalNumber,
+			fat_percent: optionalNumber
+		}).optional(),
 		earliest: z.object({
 			date: z.string(),
-			weightKg: z.number().nullable(),
-			leanMassKg: z.number().nullable(),
-			fatPercent: z.number().nullable()
-		}).nullable(),
-		weightChangeKg: z.number().nullable()
+			weight_kg: optionalNumber,
+			lean_mass_kg: optionalNumber,
+			fat_percent: optionalNumber
+		}).optional(),
+		weight_change_kg: optionalNumber
 	}),
-	workflow: workflowTelemetrySchema
+	scan: scanSchema
 };
 const compactRoutinesOutputSchema = {
 	routines: z.array(compactRoutineSchema),
-	workflow: workflowTelemetrySchema
+	scan: scanSchema
 };
 function getSupersetId(exercise) {
 	if (exercise.superset_id !== void 0) return exercise.superset_id;
@@ -2119,99 +2123,104 @@ function getSupersetId(exercise) {
 	return null;
 }
 /**
-* Format a workout object for consistent presentation
-*
-* @param workout - The workout object from the API
-* @returns A formatted workout object with standardized properties
+* Project a workout into the sparse snake_case MCP contract.
 */
-function formatWorkout(workout) {
+function projectWorkout(workout) {
 	return {
-		id: workout.id,
-		title: workout.title,
-		description: workout.description,
-		startTime: workout.start_time,
-		endTime: workout.end_time,
-		createdAt: workout.created_at,
-		updatedAt: workout.updated_at,
+		...workout.id == null ? {} : { id: workout.id },
+		...workout.routine_id == null ? {} : { routine_id: workout.routine_id },
+		...workout.title == null ? {} : { title: workout.title },
+		...workout.description == null ? {} : { description: workout.description },
+		...workout.start_time == null ? {} : { start_time: workout.start_time },
+		...workout.end_time == null ? {} : { end_time: workout.end_time },
+		...workout.created_at == null ? {} : { created_at: workout.created_at },
+		...workout.updated_at == null ? {} : { updated_at: workout.updated_at },
 		duration: calculateDuration(workout.start_time, workout.end_time),
-		exercises: workout.exercises?.map((exercise) => {
-			return {
-				index: exercise.index,
-				name: exercise.title,
-				exerciseTemplateId: exercise.exercise_template_id,
-				notes: exercise.notes,
-				supersetsId: getSupersetId(exercise),
-				sets: exercise.sets?.map((set) => ({
-					index: set.index,
-					type: set.type,
-					weight: set.weight_kg,
-					reps: set.reps,
-					distance: set.distance_meters,
-					duration: set.duration_seconds,
-					rpe: set.rpe,
-					customMetric: set.custom_metric
-				}))
-			};
-		})
+		...workout.exercises ? { exercises: workout.exercises.map((exercise) => ({
+			...exercise.index === void 0 ? {} : { index: exercise.index },
+			...exercise.title == null ? {} : { title: exercise.title },
+			...exercise.exercise_template_id == null ? {} : { exercise_template_id: exercise.exercise_template_id },
+			...exercise.notes == null ? {} : { notes: exercise.notes },
+			...getSupersetId(exercise) == null ? {} : { supersets_id: getSupersetId(exercise) ?? void 0 },
+			...exercise.sets ? { sets: exercise.sets.map((set) => ({
+				...set.index === void 0 ? {} : { index: set.index },
+				...set.type == null ? {} : { type: set.type },
+				...set.weight_kg == null ? {} : { weight_kg: set.weight_kg },
+				...set.reps == null ? {} : { reps: set.reps },
+				...set.distance_meters == null ? {} : { distance_meters: set.distance_meters },
+				...set.duration_seconds == null ? {} : { duration_seconds: set.duration_seconds },
+				...set.rpe == null ? {} : { rpe: set.rpe },
+				...set.custom_metric == null ? {} : { custom_metric: set.custom_metric }
+			})) } : {}
+		})) } : {}
 	};
 }
-/**
-* Format a routine object for consistent presentation
-*
-* @param routine - The routine object from the API
-* @returns A formatted routine object with standardized properties
-*/
-function formatRoutine(routine) {
+function summarizeWorkout(workout) {
+	const exercises = workout.exercises ?? [];
 	return {
-		id: routine.id,
-		title: routine.title,
-		folderId: routine.folder_id,
-		createdAt: routine.created_at,
-		updatedAt: routine.updated_at,
-		exercises: routine.exercises?.map((exercise) => {
-			return {
-				name: exercise.title,
-				index: exercise.index,
-				exerciseTemplateId: exercise.exercise_template_id,
-				notes: exercise.notes,
-				supersetId: getSupersetId(exercise),
-				restSeconds: exercise.rest_seconds,
-				sets: exercise.sets?.map((set) => ({
-					index: set.index,
-					type: set.type,
-					weight: set.weight_kg,
-					reps: set.reps,
-					...set.rep_range !== void 0 && { repRange: set.rep_range },
-					distance: set.distance_meters,
-					duration: set.duration_seconds,
-					...set.rpe !== void 0 && { rpe: set.rpe },
-					customMetric: set.custom_metric
-				}))
-			};
-		})
+		...workout.id == null ? {} : { id: workout.id },
+		...workout.title == null ? {} : { title: workout.title },
+		...workout.start_time == null ? {} : { start_time: workout.start_time },
+		...workout.end_time == null ? {} : { end_time: workout.end_time },
+		duration: calculateDuration(workout.start_time, workout.end_time),
+		exercise_count: exercises.length,
+		set_count: exercises.reduce((total, exercise) => total + (exercise.sets?.length ?? 0), 0)
 	};
 }
-/**
-* Format a routine folder object for consistent presentation
-*
-* @param folder - The routine folder object from the API
-* @returns A formatted routine folder object with standardized properties
-*/
-function formatRoutineFolder(folder) {
+function projectRoutine(routine) {
+	return {
+		...routine.id == null ? {} : { id: routine.id },
+		...routine.title == null ? {} : { title: routine.title },
+		...routine.folder_id == null ? {} : { folder_id: routine.folder_id },
+		...routine.created_at == null ? {} : { created_at: routine.created_at },
+		...routine.updated_at == null ? {} : { updated_at: routine.updated_at },
+		...routine.exercises ? { exercises: routine.exercises.map((exercise) => ({
+			...exercise.title == null ? {} : { title: exercise.title },
+			...exercise.index === void 0 ? {} : { index: exercise.index },
+			...exercise.exercise_template_id == null ? {} : { exercise_template_id: exercise.exercise_template_id },
+			...exercise.notes == null ? {} : { notes: exercise.notes },
+			...getSupersetId(exercise) == null ? {} : { supersets_id: getSupersetId(exercise) ?? void 0 },
+			...exercise.rest_seconds == null ? {} : { rest_seconds: exercise.rest_seconds },
+			...exercise.sets ? { sets: exercise.sets.map((set) => {
+				const repRange = set.rep_range;
+				const normalizedRepRange = repRange && (repRange.start != null || repRange.end != null) ? {
+					...repRange.start == null ? {} : { start: repRange.start },
+					...repRange.end == null ? {} : { end: repRange.end }
+				} : void 0;
+				return {
+					...set.index === void 0 ? {} : { index: set.index },
+					...set.type == null ? {} : { type: set.type },
+					...set.weight_kg == null ? {} : { weight_kg: set.weight_kg },
+					...set.reps == null ? {} : { reps: set.reps },
+					...normalizedRepRange ? { rep_range: normalizedRepRange } : {},
+					...set.distance_meters == null ? {} : { distance_meters: set.distance_meters },
+					...set.duration_seconds == null ? {} : { duration_seconds: set.duration_seconds },
+					...set.rpe == null ? {} : { rpe: set.rpe },
+					...set.custom_metric == null ? {} : { custom_metric: set.custom_metric }
+				};
+			}) } : {}
+		})) } : {}
+	};
+}
+function summarizeRoutine(routine) {
+	const exercises = routine.exercises ?? [];
+	return {
+		...routine.id == null ? {} : { id: routine.id },
+		...routine.title == null ? {} : { title: routine.title },
+		...routine.folder_id == null ? {} : { folder_id: routine.folder_id },
+		...routine.updated_at == null ? { updated_at: void 0 } : { updated_at: routine.updated_at },
+		exercise_count: exercises.length,
+		set_count: exercises.reduce((total, exercise) => total + (exercise.sets?.length ?? 0), 0)
+	};
+}
+function projectRoutineFolder(folder) {
 	return {
 		id: folder.id,
 		title: folder.title,
-		createdAt: folder.created_at,
-		updatedAt: folder.updated_at
+		created_at: folder.created_at,
+		updated_at: folder.updated_at
 	};
 }
-/**
-* Calculate duration between two ISO timestamp strings
-*
-* @param startTime - The start time as ISO string or timestamp
-* @param endTime - The end time as ISO string or timestamp
-* @returns A formatted duration string (e.g. "1h 30m 45s") or "Unknown duration" if inputs are invalid
-*/
 function calculateDuration(startTime, endTime) {
 	if (!startTime || !endTime) return "Unknown duration";
 	try {
@@ -2226,69 +2235,53 @@ function calculateDuration(startTime, endTime) {
 		return "Unknown duration";
 	}
 }
-/**
-* Format an exercise template object for consistent presentation
-*
-* @param template - The exercise template object from the API
-* @returns A formatted exercise template object with standardized properties
-*/
-function formatExerciseTemplate(template) {
-	return {
-		id: template.id,
-		title: template.title,
-		type: template.type,
-		primaryMuscleGroup: template.primary_muscle_group,
-		secondaryMuscleGroups: template.secondary_muscle_groups,
-		isCustom: template.is_custom
-	};
-}
-function formatExerciseHistoryEntry(entry) {
+function normalizeExerciseHistoryEntry(entry) {
 	return {
-		workoutId: entry.workout_id,
-		workoutTitle: entry.workout_title,
-		workoutStartTime: entry.workout_start_time,
-		workoutEndTime: entry.workout_end_time,
-		exerciseTemplateId: entry.exercise_template_id,
-		weight: entry.weight_kg,
-		reps: entry.reps,
-		distance: entry.distance_meters,
-		duration: entry.duration_seconds,
-		rpe: entry.rpe,
-		customMetric: entry.custom_metric,
-		setType: entry.set_type
+		...entry.workout_id == null ? {} : { workout_id: entry.workout_id },
+		...entry.workout_title == null ? {} : { workout_title: entry.workout_title },
+		...entry.workout_start_time == null ? {} : { workout_start_time: entry.workout_start_time },
+		...entry.workout_end_time == null ? {} : { workout_end_time: entry.workout_end_time },
+		...entry.exercise_template_id == null ? {} : { exercise_template_id: entry.exercise_template_id },
+		...entry.weight_kg == null ? {} : { weight_kg: entry.weight_kg },
+		...entry.reps == null ? {} : { reps: entry.reps },
+		...entry.distance_meters == null ? {} : { distance_meters: entry.distance_meters },
+		...entry.duration_seconds == null ? {} : { duration_seconds: entry.duration_seconds },
+		...entry.rpe == null ? {} : { rpe: entry.rpe },
+		...entry.custom_metric == null ? {} : { custom_metric: entry.custom_metric },
+		...entry.set_type == null ? {} : { set_type: entry.set_type }
 	};
 }
-function formatBodyMeasurement(measurement) {
+function normalizeBodyMeasurement(measurement) {
 	return {
 		date: measurement.date,
-		weightKg: measurement.weight_kg ?? null,
-		leanMassKg: measurement.lean_mass_kg ?? null,
-		fatPercent: measurement.fat_percent ?? null,
-		neckCm: measurement.neck_cm ?? null,
-		shoulderCm: measurement.shoulder_cm ?? null,
-		chestCm: measurement.chest_cm ?? null,
-		leftBicepCm: measurement.left_bicep_cm ?? null,
-		rightBicepCm: measurement.right_bicep_cm ?? null,
-		leftForearmCm: measurement.left_forearm_cm ?? null,
-		rightForearmCm: measurement.right_forearm_cm ?? null,
-		abdomen: measurement.abdomen ?? null,
-		waist: measurement.waist ?? null,
-		hips: measurement.hips ?? null,
-		leftThigh: measurement.left_thigh ?? null,
-		rightThigh: measurement.right_thigh ?? null,
-		leftCalf: measurement.left_calf ?? null,
-		rightCalf: measurement.right_calf ?? null
+		...measurement.weight_kg == null ? {} : { weight_kg: measurement.weight_kg },
+		...measurement.lean_mass_kg == null ? {} : { lean_mass_kg: measurement.lean_mass_kg },
+		...measurement.fat_percent == null ? {} : { fat_percent: measurement.fat_percent },
+		...measurement.neck_cm == null ? {} : { neck_cm: measurement.neck_cm },
+		...measurement.shoulder_cm == null ? {} : { shoulder_cm: measurement.shoulder_cm },
+		...measurement.chest_cm == null ? {} : { chest_cm: measurement.chest_cm },
+		...measurement.left_bicep_cm == null ? {} : { left_bicep_cm: measurement.left_bicep_cm },
+		...measurement.right_bicep_cm == null ? {} : { right_bicep_cm: measurement.right_bicep_cm },
+		...measurement.left_forearm_cm == null ? {} : { left_forearm_cm: measurement.left_forearm_cm },
+		...measurement.right_forearm_cm == null ? {} : { right_forearm_cm: measurement.right_forearm_cm },
+		...measurement.abdomen == null ? {} : { abdomen: measurement.abdomen },
+		...measurement.waist == null ? {} : { waist: measurement.waist },
+		...measurement.hips == null ? {} : { hips: measurement.hips },
+		...measurement.left_thigh == null ? {} : { left_thigh_cm: measurement.left_thigh },
+		...measurement.right_thigh == null ? {} : { right_thigh_cm: measurement.right_thigh },
+		...measurement.left_calf == null ? {} : { left_calf_cm: measurement.left_calf },
+		...measurement.right_calf == null ? {} : { right_calf_cm: measurement.right_calf }
 	};
 }
-function formatWorkoutEvent(event) {
+function projectWorkoutEvent(event) {
 	if (event.type === "updated" && "workout" in event) return {
 		type: "updated",
-		workout: formatWorkout(event.workout)
+		workout: projectWorkout(event.workout)
 	};
 	if (event.type === "deleted" && "id" in event) return {
 		type: "deleted",
 		id: event.id,
-		deletedAt: event.deleted_at
+		deleted_at: event.deleted_at
 	};
 	throw new Error(`Unsupported workout event type: ${event.type}`);
 }
@@ -2332,10 +2325,10 @@ const workoutsResponse = defineStructuredResponseContract({
 	normalize: (input) => {
 		const data = normalizePaginatedInput(input);
 		return {
-			workouts: data.items.map(formatWorkout),
+			workouts: data.items.map(summarizeWorkout),
 			page: data.page,
-			pageCount: data.pageCount,
-			hasNextPage: data.pageCount === void 0 ? void 0 : data.page < data.pageCount
+			page_count: data.pageCount,
+			has_next_page: data.pageCount === void 0 ? void 0 : data.page < data.pageCount
 		};
 	},
 	legacyJson: ({ workouts }) => workouts,
@@ -2347,9 +2340,9 @@ const workoutsResponse = defineStructuredResponseContract({
 });
 const workoutResponse = defineStructuredResponseContract({
 	outputSchema: workoutOutputSchema,
-	normalize: (data) => ({ workout: data.workout ? formatWorkout(data.workout) : null }),
+	normalize: (data) => ({ workout: data.workout ? projectWorkout(data.workout) : null }),
 	legacyJson: ({ workout }) => workout,
-	text: ({ workoutId }, { workout }) => workout === null ? `Workout with ID ${workoutId} not found` : void 0,
+	text: ({ workout_id }, { workout }) => workout === null ? `Workout with ID ${workout_id} not found` : void 0,
 	telemetry: ({ workout, expected404Outcome }) => ({
 		...workoutResultTelemetry(workout),
 		expected404Outcome
@@ -2357,17 +2350,17 @@ const workoutResponse = defineStructuredResponseContract({
 });
 const workoutCountResponse = defineStructuredResponseContract({
 	outputSchema: workoutCountOutputSchema,
-	normalize: (count) => ({ count }),
+	normalize: (count) => ({ workout_count: count }),
 	legacyJson: (output) => output,
 	telemetry: (count) => ({ itemCountBucket: bucketCount(count) })
 });
 const workoutEventsResponse = defineStructuredResponseContract({
 	outputSchema: workoutEventsOutputSchema,
 	normalize: (data) => ({
-		events: data.events?.map(formatWorkoutEvent) ?? [],
+		events: data.events?.map(projectWorkoutEvent) ?? [],
 		page: data.page,
-		pageCount: data.pageCount,
-		hasNextPage: data.pageCount === void 0 ? void 0 : data.page < data.pageCount
+		page_count: data.pageCount,
+		has_next_page: data.pageCount === void 0 ? void 0 : data.page < data.pageCount
 	}),
 	legacyJson: ({ events }) => events,
 	text: ({ since }, { events }) => events.length === 0 ? `No workout events found for the specified parameters since ${since}` : void 0,
@@ -2381,10 +2374,10 @@ const routinesResponse = defineStructuredResponseContract({
 	normalize: (input) => {
 		const data = normalizePaginatedInput(input);
 		return {
-			routines: data.items.map(formatRoutine),
+			routines: data.items.map(summarizeRoutine),
 			page: data.page,
-			pageCount: data.pageCount,
-			hasNextPage: data.pageCount === void 0 ? void 0 : data.page < data.pageCount
+			page_count: data.pageCount,
+			has_next_page: data.pageCount === void 0 ? void 0 : data.page < data.pageCount
 		};
 	},
 	legacyJson: ({ routines }) => routines,
@@ -2396,9 +2389,9 @@ const routinesResponse = defineStructuredResponseContract({
 });
 const routineResponse = defineStructuredResponseContract({
 	outputSchema: routineOutputSchema,
-	normalize: (data) => ({ routine: data.routine ? formatRoutine(data.routine) : null }),
+	normalize: (data) => ({ routine: data.routine ? projectRoutine(data.routine) : null }),
 	legacyJson: ({ routine }) => routine,
-	text: ({ routineId }, { routine }) => routine === null ? `Routine with ID ${routineId} not found` : void 0,
+	text: ({ routine_id }, { routine }) => routine === null ? `Routine with ID ${routine_id} not found` : void 0,
 	telemetry: ({ routine, expected404Outcome }) => ({
 		...routineResultTelemetry(routine),
 		expected404Outcome
@@ -2409,14 +2402,14 @@ const exerciseTemplatesResponse = defineStructuredResponseContract({
 	normalize: (input) => {
 		const data = normalizePaginatedInput(input);
 		return {
-			exerciseTemplates: data.items.map(formatExerciseTemplate),
+			exercise_templates: data.items,
 			page: data.page,
-			pageCount: data.pageCount,
-			hasNextPage: data.pageCount === void 0 ? void 0 : data.page < data.pageCount
+			page_count: data.pageCount,
+			has_next_page: data.pageCount === void 0 ? void 0 : data.page < data.pageCount
 		};
 	},
-	legacyJson: ({ exerciseTemplates }) => exerciseTemplates,
-	text: (_data, { exerciseTemplates }) => exerciseTemplates.length === 0 ? "No exercise templates found for the specified parameters" : void 0,
+	legacyJson: ({ exercise_templates }) => exercise_templates,
+	text: (_data, { exercise_templates }) => exercise_templates.length === 0 ? "No exercise templates found for the specified parameters" : void 0,
 	telemetry: (templates) => ({
 		itemCountBucket: bucketCount(normalizePaginatedInput(templates).items.length),
 		expected404Outcome: normalizePaginatedInput(templates).expected404Outcome
@@ -2424,26 +2417,26 @@ const exerciseTemplatesResponse = defineStructuredResponseContract({
 });
 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,
-	telemetry: ({ exerciseTemplate, expected404Outcome }) => ({
-		itemCountBucket: bucketCount(exerciseTemplate ? 1 : 0),
+	normalize: (data) => ({ exercise_template: data.exercise_template ?? null }),
+	legacyJson: ({ exercise_template }) => exercise_template,
+	text: ({ exercise_template_id }, { exercise_template }) => exercise_template === null ? `Exercise template with ID ${exercise_template_id} not found` : void 0,
+	telemetry: ({ exercise_template, expected404Outcome }) => ({
+		itemCountBucket: bucketCount(exercise_template ? 1 : 0),
 		expected404Outcome
 	})
 });
 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,
-	telemetry: (data) => ({ itemCountBucket: bucketCount(data.history?.length ?? 0) })
+	normalize: (data) => ({ exercise_history: data.exercise_history?.map(normalizeExerciseHistoryEntry) ?? [] }),
+	legacyJson: ({ exercise_history }) => exercise_history,
+	text: ({ exercise_template_id }, { exercise_history }) => exercise_history.length === 0 ? `No exercise history found for template ${exercise_template_id}` : void 0,
+	telemetry: (data) => ({ itemCountBucket: bucketCount(data.exercise_history?.length ?? 0) })
 });
 const searchExerciseTemplatesResponse = defineStructuredResponseContract({
 	outputSchema: exerciseTemplateSearchOutputSchema,
-	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,
+	normalize: (data) => ({ exercise_templates: data.results }),
+	legacyJson: ({ exercise_templates }) => exercise_templates,
+	text: ({ query, primary_muscle_group }, { exercise_templates }) => exercise_templates.length === 0 ? `No exercise templates found matching "${query}"${primary_muscle_group ? ` with primary muscle group "${primary_muscle_group}"` : ""}` : void 0,
 	telemetry: (data) => ({ itemCountBucket: bucketCount(data.results.length) })
 });
 const routineFoldersResponse = defineStructuredResponseContract({
@@ -2451,14 +2444,14 @@ const routineFoldersResponse = defineStructuredResponseContract({
 	normalize: (input) => {
 		const data = normalizePaginatedInput(input);
 		return {
-			routineFolders: data.items.map(formatRoutineFolder),
+			routine_folders: data.items.map(projectRoutineFolder),
 			page: data.page,
-			pageCount: data.pageCount,
-			hasNextPage: data.pageCount === void 0 ? void 0 : data.page < data.pageCount
+			page_count: data.pageCount,
+			has_next_page: data.pageCount === void 0 ? void 0 : data.page < data.pageCount
 		};
 	},
-	legacyJson: ({ routineFolders }) => routineFolders,
-	text: (_data, { routineFolders }) => routineFolders.length === 0 ? "No routine folders found for the specified parameters" : void 0,
+	legacyJson: ({ routine_folders }) => routine_folders,
+	text: (_data, { routine_folders }) => routine_folders.length === 0 ? "No routine folders found for the specified parameters" : void 0,
 	telemetry: (folders) => ({
 		itemCountBucket: bucketCount(normalizePaginatedInput(folders).items.length),
 		expected404Outcome: normalizePaginatedInput(folders).expected404Outcome
@@ -2466,11 +2459,11 @@ const routineFoldersResponse = defineStructuredResponseContract({
 });
 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,
-	telemetry: ({ routineFolder, expected404Outcome }) => ({
-		itemCountBucket: bucketCount(routineFolder ? 1 : 0),
+	normalize: (data) => ({ routine_folder: data.routine_folder ? projectRoutineFolder(data.routine_folder) : null }),
+	legacyJson: ({ routine_folder }) => routine_folder,
+	text: ({ folder_id }, { routine_folder }) => routine_folder === null ? `Routine folder with ID ${folder_id} not found` : void 0,
+	telemetry: ({ routine_folder, expected404Outcome }) => ({
+		itemCountBucket: bucketCount(routine_folder ? 1 : 0),
 		expected404Outcome
 	})
 });
@@ -2479,14 +2472,14 @@ const bodyMeasurementsResponse = defineStructuredResponseContract({
 	normalize: (input) => {
 		const data = normalizePaginatedInput(input);
 		return {
-			bodyMeasurements: data.items.map(formatBodyMeasurement),
+			body_measurements: data.items.map(normalizeBodyMeasurement),
 			page: data.page,
-			pageCount: data.pageCount,
-			hasNextPage: data.pageCount === void 0 ? void 0 : data.page < data.pageCount
+			page_count: data.pageCount,
+			has_next_page: data.pageCount === void 0 ? void 0 : data.page < data.pageCount
 		};
 	},
-	legacyJson: ({ bodyMeasurements }) => bodyMeasurements,
-	text: (_data, { bodyMeasurements }) => bodyMeasurements.length === 0 ? "No body measurements found for the specified parameters" : void 0,
+	legacyJson: ({ body_measurements }) => body_measurements,
+	text: (_data, { body_measurements }) => body_measurements.length === 0 ? "No body measurements found for the specified parameters" : void 0,
 	telemetry: (measurements) => ({
 		itemCountBucket: bucketCount(normalizePaginatedInput(measurements).items.length),
 		expected404Outcome: normalizePaginatedInput(measurements).expected404Outcome
@@ -2494,11 +2487,11 @@ const bodyMeasurementsResponse = defineStructuredResponseContract({
 });
 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,
-	telemetry: ({ bodyMeasurement, expected404Outcome }) => ({
-		itemCountBucket: bucketCount(bodyMeasurement ? 1 : 0),
+	normalize: (data) => ({ body_measurement: data.body_measurement ? normalizeBodyMeasurement(data.body_measurement) : null }),
+	legacyJson: ({ body_measurement }) => body_measurement,
+	text: ({ date }, { body_measurement }) => body_measurement === null ? `No body measurement found for date ${date}` : void 0,
+	telemetry: ({ body_measurement, expected404Outcome }) => ({
+		itemCountBucket: bucketCount(body_measurement ? 1 : 0),
 		expected404Outcome
 	})
 });
@@ -2511,17 +2504,46 @@ const userResponse = defineStructuredResponseContract({
 });
 const trainingSummaryResponse = defineStructuredResponseContract({
 	outputSchema: trainingSummaryOutputSchema,
-	normalize: (data) => data,
+	normalize: (data) => {
+		const { workflow, ...result } = data;
+		const { latest, earliest, weight_change_kg, ...body_measurements } = result.body_measurements;
+		return {
+			...result,
+			body_measurements: {
+				...body_measurements,
+				...latest ? { latest } : {},
+				...earliest ? { earliest } : {},
+				...weight_change_kg == null ? {} : { weight_change_kg }
+			},
+			scan: {
+				pages: workflow.pagination,
+				items: workflow.itemsScanned
+			}
+		};
+	},
 	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,
+	text: (data) => data.workouts.count === 0 && data.body_measurements.count === 0 ? "No workouts or body measurements found for the specified period" : void 0,
 	telemetry: (data) => ({
-		itemCountBucket: bucketCount(data.workouts.count + data.bodyMeasurements.count),
+		itemCountBucket: bucketCount(data.workouts.count + data.body_measurements.count),
 		workflow: workflowResultTelemetry(data.workflow)
 	})
 });
 const compactRoutinesResponse = defineStructuredResponseContract({
 	outputSchema: compactRoutinesOutputSchema,
-	normalize: (data) => data,
+	normalize: (data) => {
+		const { workflow, ...result } = data;
+		return {
+			...result,
+			routines: result.routines.map((routine) => ({
+				...routine,
+				...routine.folder_id == null ? { folder_id: void 0 } : {}
+			})),
+			scan: {
+				pages: workflow.pagination,
+				items: workflow.itemsScanned
+			}
+		};
+	},
 	legacyJson: ({ routines }) => routines,
 	text: (_data, { routines }) => routines.length === 0 ? "No routines found matching the query" : void 0,
 	telemetry: (data) => ({
@@ -2529,22 +2551,22 @@ const compactRoutinesResponse = defineStructuredResponseContract({
 		workflow: workflowResultTelemetry(data.workflow)
 	})
 });
-const createWorkoutResponse = defineJsonResponseContract((workout) => workout ? { json: formatWorkout(workout) } : { text: "Failed to create workout: Server returned no data" }, (workout) => workoutResultTelemetry(workout));
-const updateWorkoutResponse = defineJsonResponseContract((data) => data.workout ? { json: formatWorkout(data.workout) } : { text: `Failed to update workout with ID ${data.workoutId}` }, (data) => workoutResultTelemetry(data.workout));
+const createWorkoutResponse = defineJsonResponseContract((workout) => workout ? { json: projectWorkout(workout) } : { text: "Failed to create workout: Server returned no data" }, (workout) => workoutResultTelemetry(workout));
+const updateWorkoutResponse = defineJsonResponseContract((data) => data.workout ? { json: projectWorkout(data.workout) } : { text: `Failed to update workout with ID ${data.workout_id}` }, (data) => workoutResultTelemetry(data.workout));
 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),
+	json: projectRoutine(data.routine),
 	additionalText: data.usesRepRanges ? [repRangeDisplayWarningText] : []
 } : { text: "Failed to create routine: Server returned no data" }, (data) => routineResultTelemetry(data.routine));
 const updateRoutineResponse = defineJsonResponseContract((data) => data.routine ? {
-	json: formatRoutine(data.routine),
+	json: projectRoutine(data.routine),
 	additionalText: data.usesRepRanges ? [repRangeDisplayWarningText] : []
-} : { text: `Failed to update routine with ID ${data.routineId}` }, (data) => routineResultTelemetry(data.routine));
+} : { text: `Failed to update routine with ID ${data.routine_id}` }, (data) => routineResultTelemetry(data.routine));
 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" }, (folder) => ({ itemCountBucket: bucketCount(folder ? 1 : 0) }));
+const createRoutineFolderResponse = defineJsonResponseContract((folder) => folder ? { json: projectRoutineFolder(folder) } : { text: "Failed to create routine folder: Server returned no data" }, (folder) => ({ itemCountBucket: bucketCount(folder ? 1 : 0) }));
 const createBodyMeasurementResponse = defineJsonResponseContract((date) => ({ text: `Body measurement for ${date} created successfully.` }), () => ({ itemCountBucket: "1" }));
 const updateBodyMeasurementResponse = defineJsonResponseContract((date) => ({ text: `Body measurement for ${date} updated successfully.` }), () => ({ itemCountBucket: "1" }));
 //#endregion
@@ -2581,33 +2603,103 @@ function registerHevyResources(server, runtime) {
 		description: "Total number of workouts in the Hevy account",
 		mimeType: JSON_MIME_TYPE
 	}, async (uri) => {
-		return createJsonResourceResult(uri, { count: (await runtime.getClient().getWorkoutCount())?.workout_count ?? 0 });
+		return createJsonResourceResult(uri, { workout_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) => {
-		return createJsonResourceResult(uri, (await runtime.catalog.get()).map(formatExerciseTemplate));
+		return createJsonResourceResult(uri, await runtime.catalog.get());
 	});
 	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(runtime)).map(formatRoutineFolder));
+		return createJsonResourceResult(uri, (await fetchAllRoutineFolders(runtime)).map(projectRoutineFolder));
 	});
 }
 //#endregion
 //#region ../core/src/server-metadata.ts
 const SERVER_NAME = "hevy-mcp";
-const SERVER_VERSION = "4.1.3";
+const SERVER_VERSION = "5.0.0";
 const SERVER_INSTRUCTIONS = [
 	"Hevy MCP connects clients to the authenticated user's Hevy workout-tracking data, including workouts, routines, exercise templates, routine folders, body measurements, and profile information. HEVY_API_KEY must contain a valid Hevy API key for local stdio use.",
 	"Safety: all get-* and search-* tools are read-only. create-* and update-* tools mutate Hevy data. Creates are additive and non-idempotent, so repeating one can create duplicates. Updates can overwrite existing data. Delete operations are not available.",
 	"Workflow: search exercise templates first, then use the returned template IDs when creating workouts or routines. To create a completed workout from a routine, fetch the routine as a plan, then obtain the actual completed sets and end time from the user; never invent completion data.",
-	"Pagination: start at page 1 and fetch only the pages needed. Most list tools allow pageSize up to 10; get-exercise-templates allows up to 100.",
+	"Pagination: start at page 1 and fetch only the pages needed. Most list tools allow page_size up to 10; get-exercise-templates allows page_size up to 100.",
 	"Rate limits and retries: minimize repeated calls. If Hevy returns HTTP 429, follow its retry guidance. Transient read requests retry automatically, but write requests do not; confirm uncertain write outcomes before trying again."
 ].join("\n\n");
 //#endregion
+//#region ../core/src/utils/compact-json-schema.ts
+function isRecord$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isNullSchema(value) {
+	return isRecord$1(value) && value.type === "null" && Object.keys(value).length === 1;
+}
+function compactNullableSchema(value) {
+	if (Array.isArray(value)) return value.map(compactNullableSchema);
+	if (!isRecord$1(value)) return value;
+	const anyOf = value.anyOf;
+	if (Array.isArray(anyOf) && anyOf.length === 2) {
+		const nullableBranch = anyOf.find(isNullSchema);
+		const valueBranch = anyOf.find((branch) => !isNullSchema(branch));
+		if (nullableBranch !== void 0 && isRecord$1(valueBranch) && typeof valueBranch.type === "string") {
+			const { anyOf: _anyOf, ...metadata } = value;
+			return compactNullableSchema({
+				...valueBranch,
+				...metadata,
+				type: [valueBranch.type, "null"]
+			});
+		}
+	}
+	return Object.fromEntries(Object.entries(value).map(([key, nested]) => [key, compactNullableSchema(nested)]));
+}
+function omitOutputObjectRestrictions(value) {
+	if (Array.isArray(value)) return value.map(omitOutputObjectRestrictions);
+	if (!isRecord$1(value)) return value;
+	return Object.fromEntries(Object.entries(value).filter(([key, nested]) => key !== "additionalProperties" || nested !== false).map(([key, nested]) => [key, omitOutputObjectRestrictions(nested)]));
+}
+function convertSchema(schema, io) {
+	const converted = z.toJSONSchema(schema, {
+		target: "draft-2020-12",
+		io
+	});
+	if (!isRecord$1(converted)) throw new Error("Zod emitted a non-object root schema");
+	const compacted = compactNullableSchema(converted);
+	if (!isRecord$1(compacted)) throw new Error("Nullable schema compaction changed the root schema");
+	const output = io === "output" ? omitOutputObjectRestrictions(compacted) : compacted;
+	if (!isRecord$1(output)) throw new Error("Output schema compaction changed the root schema");
+	delete output.$schema;
+	return output;
+}
+/**
+* Keep Zod validation while advertising a compact JSON Schema.
+*
+* Zod emits nullable values as `anyOf`; draft 2020-12 also permits a type
+* array. The MCP wire envelope does not need a repeated `$schema` marker, and
+* structured output is validated by the original Zod schema before sending.
+*/
+function compactJsonSchema(schema) {
+	let inputSchema;
+	let outputSchema;
+	Object.defineProperty(schema["~standard"], "jsonSchema", {
+		configurable: true,
+		value: {
+			input: () => {
+				inputSchema ??= convertSchema(schema, "input");
+				return inputSchema;
+			},
+			output: () => {
+				outputSchema ??= convertSchema(schema, "output");
+				return outputSchema;
+			}
+		},
+		writable: true
+	});
+	return schema;
+}
+//#endregion
 //#region ../core/src/utils/tool-helpers.ts
 /**
 * Type-safe utilities for MCP tool handlers
@@ -2645,7 +2737,7 @@ function requireClient(client) {
 * ```
 */
 function createTypedToolHandler(schema, handler) {
-	const zodSchema = z.object(schema);
+	const zodSchema = z.strictObject(schema);
 	return async (args) => {
 		return handler(zodSchema.parse(args));
 	};
@@ -2659,11 +2751,12 @@ function registerToolDefinition(server, runtime, definition) {
 		kind: definition.kind,
 		operation: definition.operation
 	});
+	const inputSchema = compactJsonSchema(z.strictObject(definition.inputSchema));
 	const config = {
 		description: definition.description,
-		inputSchema: z.object(definition.inputSchema),
+		inputSchema,
 		annotations: definition.annotations,
-		...definition.kind === "read" ? { outputSchema: z.object(definition.outputSchema) } : {}
+		...definition.kind === "read" ? { outputSchema: compactJsonSchema(z.object(definition.outputSchema)) } : {}
 	};
 	server.registerTool(definition.name, config, callback);
 }
@@ -2701,16 +2794,6 @@ function updateAnnotations(title) {
 	};
 }
 //#endregion
-//#region ../core/src/utils/tool-descriptions.ts
-function describeTool({ summary, aliases, useCase, importantNotes }) {
-	return [
-		summary,
-		`Aliases: ${aliases.join(", ")}.`,
-		`<use_case>${useCase}</use_case>`,
-		`<important_notes>${importantNotes}</important_notes>`
-	].join(" ");
-}
-//#endregion
 //#region ../core/src/utils/json-parser.ts
 /**
 * Preprocessor to handle MCP clients that send JSON-stringified arrays
@@ -2732,143 +2815,156 @@ function parseJsonArray(val) {
 }
 //#endregion
 //#region ../core/src/tools/input-schemas.ts
-/** Build the page and pageSize fields shared by paginated tools. */
+/** Build the page and page_size 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)
+		page_size: z.coerce.number().int().gte(1).lte(maxPageSize).default(defaultPageSize)
 	};
 }
 const nonEmptyId = z.string().min(1);
-const exerciseTemplateInputShape = {
+const exerciseTemplatePayloadShape = {
 	title: z.string().min(1),
-	exerciseType: exerciseTypeEnum,
-	equipmentCategory: equipmentCategoryEnum,
-	muscleGroup: muscleGroupEnum,
-	otherMuscles: z.array(muscleGroupEnum).default([])
+	exercise_type: exerciseTypeEnum,
+	equipment_category: equipmentCategoryEnum,
+	muscle_group: muscleGroupEnum,
+	other_muscles: z.array(muscleGroupEnum).default([])
 };
-const routineFolderInputShape = { name: z.string().min(1) };
+const exerciseTemplateInputShape = z.strictObject({ exercise: z.strictObject(exerciseTemplatePayloadShape) }).shape;
+const routineFolderPayloadShape = { title: z.string().min(1) };
+const routineFolderInputShape = z.strictObject({ routine_folder: z.strictObject(routineFolderPayloadShape) }).shape;
 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 rpeEnum = z.union([
+	z.literal(6),
+	z.literal(7),
+	z.literal(7.5),
+	z.literal(8),
+	z.literal(8.5),
+	z.literal(9),
+	z.literal(9.5),
+	z.literal(10)
+]);
 const workoutSetShape = {
 	type: setTypeEnum,
-	weight: z.coerce.number().optional().nullable(),
-	weightKg: z.coerce.number().optional().nullable(),
+	weight_kg: 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()
+	distance_meters: z.coerce.number().int().optional().nullable(),
+	duration_seconds: z.coerce.number().int().optional().nullable(),
+	rpe: rpeEnum.optional().nullable(),
+	custom_metric: z.coerce.number().optional().nullable()
 };
+const workoutSetSchema = z.strictObject(workoutSetShape);
 const workoutExerciseShape = {
-	exerciseTemplateId: nonEmptyId,
-	supersetId: z.coerce.number().nullable().optional(),
+	exercise_template_id: nonEmptyId,
+	superset_id: z.coerce.number().nullable().optional(),
 	notes: z.string().optional().nullable(),
-	sets: z.array(z.object(workoutSetShape))
+	sets: z.array(workoutSetSchema)
 };
-const workoutPayloadShape = {
+const workoutExerciseSchema = z.strictObject(workoutExerciseShape);
+const workoutExercisesSchema = z.preprocess(parseJsonArray, z.array(workoutExerciseSchema));
+const replaceWorkoutPayloadShape = {
 	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)))
+	start_time: utcSecondTimestamp,
+	end_time: utcSecondTimestamp,
+	is_private: z.boolean().default(false),
+	exercises: workoutExercisesSchema
 };
+const replaceWorkoutPayloadSchema = z.strictObject(replaceWorkoutPayloadShape);
+const workoutInputShape = z.strictObject({ workout: replaceWorkoutPayloadSchema }).shape;
+z.strictObject({
+	workout_id: nonEmptyId,
+	workout: replaceWorkoutPayloadSchema
+}).shape;
+const workoutMetadataPatchSchema = z.strictObject({
+	title: z.string().min(1).optional(),
+	description: z.string().nullable().optional(),
+	start_time: utcSecondTimestamp.optional(),
+	end_time: utcSecondTimestamp.optional(),
+	is_private: z.boolean().optional()
+}).refine((patch) => Object.values(patch).some((value) => value !== void 0), "Include at least one workout metadata field").meta({ minProperties: 1 });
+const updateWorkoutInputShape = z.strictObject({
+	workout_id: nonEmptyId,
+	workout: workoutMetadataPatchSchema
+}).shape;
+const replaceWorkoutExercisesInputShape = z.strictObject({
+	workout_id: nonEmptyId,
+	workout: z.strictObject({ exercises: workoutExercisesSchema })
+}).shape;
 const routineSetShape = {
 	type: setTypeEnum,
-	weight: z.coerce.number().optional(),
-	weightKg: z.coerce.number().optional(),
+	weight_kg: 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
+	distance_meters: z.coerce.number().int().optional(),
+	duration_seconds: z.coerce.number().int().optional(),
+	rep_range: zStrictOptionalRepRange,
+	custom_metric: z.coerce.number().optional()
 };
+const routineSetSchema = z.strictObject(routineSetShape);
 const routineExerciseShape = {
-	exerciseTemplateId: nonEmptyId,
-	supersetId: z.coerce.number().nullable().optional(),
-	restSeconds: z.coerce.number().int().min(0).optional(),
+	exercise_template_id: nonEmptyId,
+	superset_id: z.coerce.number().nullable().optional(),
+	rest_seconds: z.coerce.number().int().min(0).optional(),
 	notes: z.string().optional(),
-	sets: z.array(z.object(routineSetShape))
+	sets: z.array(routineSetSchema)
 };
+const routineExerciseSchema = z.strictObject(routineExerciseShape);
+const routineExercisesSchema = z.preprocess(parseJsonArray, z.array(routineExerciseSchema));
 const routinePayloadShape = {
 	title: z.string().min(1),
-	folderId: z.coerce.number().nullable().optional(),
+	folder_id: z.coerce.number().nullable().optional(),
 	notes: z.string().optional(),
-	exercises: z.preprocess(parseJsonArray, z.array(z.object(routineExerciseShape)))
+	exercises: routineExercisesSchema
 };
-const bodyMeasurementFieldsSchema = {
-	weightKg: zNullableNumber.describe("Body weight in kilograms"),
-	leanMassKg: zNullableNumber.describe("Lean body mass in kilograms"),
-	fatPercent: zNullableNumber.describe("Body fat percentage"),
-	neckCm: zNullableNumber.describe("Neck circumference in centimeters"),
-	shoulderCm: zNullableNumber.describe("Shoulder circumference in centimeters"),
-	chestCm: zNullableNumber.describe("Chest circumference in centimeters"),
-	leftBicepCm: zNullableNumber.describe("Left bicep circumference in centimeters"),
-	rightBicepCm: zNullableNumber.describe("Right bicep circumference in centimeters"),
-	leftForearmCm: zNullableNumber.describe("Left forearm circumference in centimeters"),
-	rightForearmCm: zNullableNumber.describe("Right forearm circumference in centimeters"),
-	abdomen: zNullableNumber.describe("Abdomen circumference in centimeters"),
-	waist: zNullableNumber.describe("Waist circumference in centimeters"),
-	hips: zNullableNumber.describe("Hips circumference in centimeters"),
-	leftThigh: zNullableNumber.describe("Left thigh circumference in centimeters"),
-	rightThigh: zNullableNumber.describe("Right thigh circumference in centimeters"),
-	leftCalf: zNullableNumber.describe("Left calf circumference in centimeters"),
-	rightCalf: zNullableNumber.describe("Right calf circumference in centimeters")
+const routinePayloadSchema = z.strictObject(routinePayloadShape);
+const createRoutineInputShape = z.strictObject({ routine: routinePayloadSchema }).shape;
+const routineUpdatePayloadShape = {
+	title: z.string().min(1),
+	notes: z.string().optional(),
+	exercises: routineExercisesSchema
 };
-const measurementFieldToApiKey = {
-	weightKg: "weight_kg",
-	leanMassKg: "lean_mass_kg",
-	fatPercent: "fat_percent",
-	neckCm: "neck_cm",
-	shoulderCm: "shoulder_cm",
-	chestCm: "chest_cm",
-	leftBicepCm: "left_bicep_cm",
-	rightBicepCm: "right_bicep_cm",
-	leftForearmCm: "left_forearm_cm",
-	rightForearmCm: "right_forearm_cm",
-	abdomen: "abdomen",
-	waist: "waist",
-	hips: "hips",
-	leftThigh: "left_thigh",
-	rightThigh: "right_thigh",
-	leftCalf: "left_calf",
-	rightCalf: "right_calf"
+const routineUpdatePayloadSchema = z.strictObject(routineUpdatePayloadShape);
+const updateRoutineInputShape = z.strictObject({
+	routine_id: nonEmptyId,
+	routine: routineUpdatePayloadSchema
+}).shape;
+const bodyMeasurementFieldsSchema = {
+	weight_kg: zNullableNumber,
+	lean_mass_kg: zNullableNumber,
+	fat_percent: zNullableNumber,
+	neck_cm: zNullableNumber,
+	shoulder_cm: zNullableNumber,
+	chest_cm: zNullableNumber,
+	left_bicep_cm: zNullableNumber,
+	right_bicep_cm: zNullableNumber,
+	left_forearm_cm: zNullableNumber,
+	right_forearm_cm: zNullableNumber,
+	abdomen: zNullableNumber.describe("Circumference in centimeters."),
+	waist: zNullableNumber.describe("Circumference in centimeters."),
+	hips: zNullableNumber.describe("Circumference in centimeters."),
+	left_thigh: zNullableNumber,
+	right_thigh: zNullableNumber,
+	left_calf: zNullableNumber,
+	right_calf: zNullableNumber
 };
+z.strictObject(bodyMeasurementFieldsSchema);
+const createBodyMeasurementInputSchema = z.strictObject({
+	date: calendarDate,
+	...bodyMeasurementFieldsSchema
+});
+const updateBodyMeasurementInputSchema = z.strictObject({
+	date: calendarDate,
+	...bodyMeasurementFieldsSchema
+});
+const createBodyMeasurementInputShape = createBodyMeasurementInputSchema.shape;
+const updateBodyMeasurementInputShape = updateBodyMeasurementInputSchema.shape;
 //#endregion
-//#region ../core/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
-			}))
-		}))
-	};
-}
+//#region ../core/src/tools/mutation-semantics.ts
 function buildRepRange(repRange) {
 	if (!repRange) return null;
 	const start = repRange.start ?? void 0;
@@ -2888,14 +2984,14 @@ function getFixedRepsFromRepRange(repRange) {
 }
 function buildRoutineSets(sets, mode) {
 	return sets.map((set) => {
-		const repRange = buildRepRange(set.repRange);
+		const repRange = buildRepRange(set.rep_range);
 		const reps = typeof set.reps === "number" ? set.reps : getFixedRepsFromRepRange(repRange);
 		const common = {
-			weight_kg: set.weight ?? set.weightKg ?? null,
+			weight_kg: set.weight_kg ?? null,
 			reps: reps ?? null,
-			distance_meters: set.distance ?? set.distanceMeters ?? null,
-			duration_seconds: set.duration ?? set.durationSeconds ?? null,
-			custom_metric: set.customMetric ?? null
+			distance_meters: set.distance_meters ?? null,
+			duration_seconds: set.duration_seconds ?? null,
+			custom_metric: set.custom_metric ?? null
 		};
 		if (mode === "create") return {
 			...common,
@@ -2915,9 +3011,9 @@ function buildRoutinePayload(input, mode) {
 		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,
+			exercise_template_id: exercise.exercise_template_id,
+			superset_id: exercise.superset_id ?? null,
+			rest_seconds: exercise.rest_seconds ?? null,
 			notes: exercise.notes ?? null,
 			sets
 		};
@@ -2925,7 +3021,7 @@ function buildRoutinePayload(input, mode) {
 	if (mode === "create") return {
 		payload: {
 			title: input.title,
-			folder_id: input.folderId ?? null,
+			folder_id: input.folder_id ?? null,
 			notes: input.notes ?? "",
 			exercises
 		},
@@ -2940,27 +3036,71 @@ function buildRoutinePayload(input, mode) {
 		usesRepRanges
 	};
 }
+const workoutUpdateMetadataSchema = z.object({
+	title: z.string().min(1),
+	start_time: utcSecondTimestamp,
+	end_time: utcSecondTimestamp
+});
+/**
+* Map fetched API exercises to the update shape without validating legacy data.
+* Caller-supplied replacement exercises are still validated by their input schema.
+*/
+function preserveWorkoutExercises(current) {
+	return current.exercises?.map((exercise) => ({
+		exercise_template_id: exercise.exercise_template_id,
+		superset_id: exercise.supersets_id ?? null,
+		notes: exercise.notes ?? null,
+		sets: exercise.sets?.map((set) => ({
+			...set.type === void 0 ? {} : { type: set.type },
+			weight_kg: set.weight_kg ?? null,
+			reps: set.reps ?? null,
+			distance_meters: set.distance_meters ?? null,
+			duration_seconds: set.duration_seconds ?? null,
+			rpe: set.rpe,
+			custom_metric: set.custom_metric ?? null
+		})) ?? []
+	})) ?? [];
+}
+function buildWorkoutUpdatePayload(current, patch, replacementExercises) {
+	return {
+		...workoutUpdateMetadataSchema.parse({
+			title: patch.title !== void 0 ? patch.title : current.title,
+			start_time: patch.start_time !== void 0 ? patch.start_time : current.start_time,
+			end_time: patch.end_time !== void 0 ? patch.end_time : current.end_time
+		}),
+		description: patch.description !== void 0 ? patch.description : current.description ?? null,
+		exercises: replacementExercises === void 0 ? preserveWorkoutExercises(current) : replacementExercises,
+		...patch.is_private !== void 0 ? { is_private: patch.is_private } : {}
+	};
+}
+const measurementKeys = [
+	"weight_kg",
+	"lean_mass_kg",
+	"fat_percent",
+	"neck_cm",
+	"shoulder_cm",
+	"chest_cm",
+	"left_bicep_cm",
+	"right_bicep_cm",
+	"left_forearm_cm",
+	"right_forearm_cm",
+	"abdomen",
+	"waist",
+	"hips",
+	"left_thigh",
+	"right_thigh",
+	"left_calf",
+	"right_calf"
+];
 /** Omit nullish measurement values because the API rejects explicit nulls. */
 function buildMeasurementPayload(fields) {
 	const payload = {};
-	for (const [camelKey, apiKey] of Object.entries(measurementFieldToApiKey)) {
-		const value = fields[camelKey];
-		if (value != null) payload[apiKey] = value;
+	for (const key of measurementKeys) {
+		const value = fields[key];
+		if (value != null) payload[key] = value;
 	}
 	return payload;
 }
-function buildExerciseTemplateRequest(input) {
-	return { exercise: {
-		title: input.title,
-		exercise_type: input.exerciseType,
-		equipment_category: input.equipmentCategory,
-		muscle_group: input.muscleGroup,
-		other_muscles: input.otherMuscles
-	} };
-}
-function buildRoutineFolderRequest(input) {
-	return { routine_folder: { title: input.name } };
-}
 //#endregion
 //#region ../core/src/utils/hevy-error-policy.ts
 const READ_RESOURCE_ENDPOINTS = /* @__PURE__ */ new Set([
@@ -2992,41 +3132,26 @@ 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 getBodyMeasurementSchema = { date: calendarDate };
+const createBodyMeasurementSchema = createBodyMeasurementInputShape;
+const updateBodyMeasurementSchema = updateBodyMeasurementInputShape;
 const bodyMeasurementToolDefinitions = [
 	{
 		name: "get-body-measurements",
 		feature: "measurements",
 		operation: "list",
-		description: describeTool({
-			summary: "Read-only. Lists dated body measurements for the account.",
-			aliases: [
-				"body stats history",
-				"list weigh-ins",
-				"measurement log"
-			],
-			useCase: "Use to browse measurement history; use get-body-measurement for one exact date.",
-			importantNotes: "Results are paginated; page starts at 1 and pageSize is limited to 10."
-		}),
+		description: "Read-only. Lists dated body measurements; results are paginated. Use get-body-measurement for one date.",
 		inputSchema: getBodyMeasurementsSchema,
 		outputSchema: bodyMeasurementsResponse.outputSchema,
 		annotations: readOnlyAnnotations("Get Body Measurements"),
 		kind: "read",
 		responseContract: bodyMeasurementsResponse,
 		execute: async (runtime, args) => {
-			const { page, pageSize } = args;
+			const { page, page_size } = args;
 			try {
 				const data = await runtime.getClient().getBodyMeasurements({
 					page,
-					pageSize
+					pageSize: page_size
 				});
 				return {
 					items: data?.body_measurements ?? [],
@@ -3047,16 +3172,7 @@ const bodyMeasurementToolDefinitions = [
 		name: "get-body-measurement",
 		feature: "measurements",
 		operation: "get",
-		description: describeTool({
-			summary: "Read-only. Retrieves the body measurement entry for one date.",
-			aliases: [
-				"get weigh-in",
-				"show body stats",
-				"measurement by date"
-			],
-			useCase: "Use when the exact measurement date is known; use get-body-measurements to browse dates.",
-			importantNotes: "date must use YYYY-MM-DD; at most one entry exists per date."
-		}),
+		description: "Read-only. Gets the body measurement for one YYYY-MM-DD date. Use get-body-measurements to browse dates.",
 		inputSchema: getBodyMeasurementSchema,
 		outputSchema: bodyMeasurementResponse.outputSchema,
 		annotations: readOnlyAnnotations("Get Body Measurement"),
@@ -3066,12 +3182,12 @@ const bodyMeasurementToolDefinitions = [
 			const { date } = args;
 			try {
 				return {
-					bodyMeasurement: await runtime.getClient().getBodyMeasurement(date),
+					body_measurement: await runtime.getClient().getBodyMeasurement(date),
 					date
 				};
 			} catch (error) {
 				if (isExpectedReadNotFound(error)) return {
-					bodyMeasurement: null,
+					body_measurement: null,
 					date,
 					expected404Outcome: "not_found"
 				};
@@ -3083,16 +3199,7 @@ const bodyMeasurementToolDefinitions = [
 		name: "create-body-measurement",
 		feature: "measurements",
 		operation: "create",
-		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."
-		}),
+		description: "Writes a body measurement for a new YYYY-MM-DD date. Existing dates conflict; retries are not idempotent.",
 		inputSchema: createBodyMeasurementSchema,
 		annotations: createAnnotations("Create Body Measurement"),
 		kind: "write",
@@ -3110,16 +3217,7 @@ const bodyMeasurementToolDefinitions = [
 		name: "update-body-measurement",
 		feature: "measurements",
 		operation: "update",
-		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."
-		}),
+		description: "Mutates numeric fields on an existing YYYY-MM-DD measurement. Omitted fields remain unchanged; values cannot be cleared.",
 		inputSchema: updateBodyMeasurementSchema,
 		annotations: updateAnnotations("Update Body Measurement"),
 		kind: "write",
@@ -3127,7 +3225,7 @@ const bodyMeasurementToolDefinitions = [
 		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.");
+			if (Object.keys(payload).length === 0) throw new Error("No measurement fields provided. Include at least one numeric measurement field (e.g. weight_kg) to update.");
 			await runtime.getClient().updateBodyMeasurement(date, payload);
 			return date;
 		}
@@ -3139,34 +3237,25 @@ const getRoutineFoldersSchema = paginationShape({
 	defaultPageSize: 5,
 	maxPageSize: 10
 });
-const getRoutineFolderSchema = { folderId: nonEmptyId };
+const getRoutineFolderSchema = { folder_id: nonEmptyId };
 const createRoutineFolderSchema = routineFolderInputShape;
 const folderToolDefinitions = [
 	{
 		name: "get-routine-folders",
 		feature: "folders",
 		operation: "list",
-		description: describeTool({
-			summary: "Read-only. Lists default and custom routine folders.",
-			aliases: [
-				"list folders",
-				"browse routine groups",
-				"show plan folders"
-			],
-			useCase: "Use to browse folder organization or discover folder IDs for routine creation.",
-			importantNotes: "Results are paginated; page starts at 1 and pageSize is limited to 10."
-		}),
+		description: "Read-only. Lists routine folders and IDs; results are paginated.",
 		inputSchema: getRoutineFoldersSchema,
 		outputSchema: routineFoldersResponse.outputSchema,
 		annotations: readOnlyAnnotations("Get Routine Folders"),
 		kind: "read",
 		responseContract: routineFoldersResponse,
 		execute: async (runtime, args) => {
-			const { page, pageSize } = args;
+			const { page, page_size } = args;
 			try {
 				const data = await runtime.getClient().getRoutineFolders({
 					page,
-					pageSize
+					pageSize: page_size
 				});
 				return {
 					items: data?.routine_folders ?? [],
@@ -3187,32 +3276,23 @@ const folderToolDefinitions = [
 		name: "get-routine-folder",
 		feature: "folders",
 		operation: "get",
-		description: describeTool({
-			summary: "Read-only. Retrieves one routine folder's metadata by ID.",
-			aliases: [
-				"show folder",
-				"folder details",
-				"routine folder metadata"
-			],
-			useCase: "Use for one known folder; use get-routine-folders to browse or discover folder IDs.",
-			importantNotes: "Requires a folderId from get-routine-folders or a prior create response."
-		}),
+		description: "Read-only. Gets one routine folder by folder_id. Use get-routine-folders to discover IDs.",
 		inputSchema: getRoutineFolderSchema,
 		outputSchema: routineFolderResponse.outputSchema,
 		annotations: readOnlyAnnotations("Get Routine Folder"),
 		kind: "read",
 		responseContract: routineFolderResponse,
 		execute: async (runtime, args) => {
-			const { folderId } = args;
+			const { folder_id } = args;
 			try {
 				return {
-					routineFolder: await runtime.getClient().getRoutineFolder(folderId),
-					folderId
+					routine_folder: await runtime.getClient().getRoutineFolder(folder_id),
+					folder_id
 				};
 			} catch (error) {
 				if (isExpectedReadNotFound(error)) return {
-					routineFolder: null,
-					folderId,
+					routine_folder: null,
+					folder_id,
 					expected404Outcome: "not_found"
 				};
 				throw error;
@@ -3223,169 +3303,109 @@ const folderToolDefinitions = [
 		name: "create-routine-folder",
 		feature: "folders",
 		operation: "create",
-		description: 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."
-		}),
+		description: "Writes a routine folder. Retries or reused titles can create duplicates.",
 		inputSchema: createRoutineFolderSchema,
 		annotations: createAnnotations("Create Routine Folder"),
 		kind: "write",
 		responseContract: createRoutineFolderResponse,
 		execute: async (runtime, args) => {
-			return runtime.getClient().createRoutineFolder(buildRoutineFolderRequest(args));
+			return runtime.getClient().createRoutineFolder(args);
 		}
 	}
 ];
-//#endregion
-//#region ../core/src/tools/routines.ts
-const getRoutinesSchema = paginationShape({
-	defaultPageSize: 5,
-	maxPageSize: 10
-});
-const getRoutinesDefinition = {
-	name: "get-routines",
-	feature: "routines",
-	operation: "list",
-	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 }) => {
-		try {
-			const data = await runtime.getClient().getRoutines({
-				page,
-				pageSize
-			});
-			return {
-				items: data?.routines ?? [],
-				page,
-				pageCount: data?.page_count
-			};
-		} catch (error) {
-			if (isExpectedListPageNotFound(error, page)) return {
-				items: [],
-				page,
-				expected404Outcome: "end_of_list"
-			};
-			throw error;
+const routineToolDefinitions = [
+	{
+		name: "get-routines",
+		feature: "routines",
+		operation: "list",
+		description: "Read-only. Lists compact routine summaries. Use get-routine for exercises and sets; results are paginated.",
+		inputSchema: paginationShape({
+			defaultPageSize: 5,
+			maxPageSize: 10
+		}),
+		kind: "read",
+		outputSchema: routinesResponse.outputSchema,
+		annotations: readOnlyAnnotations("Get Routines"),
+		responseContract: routinesResponse,
+		execute: async (runtime, { page, page_size }) => {
+			try {
+				const data = await runtime.getClient().getRoutines({
+					page,
+					pageSize: page_size
+				});
+				return {
+					items: data?.routines ?? [],
+					page,
+					pageCount: data?.page_count
+				};
+			} catch (error) {
+				if (isExpectedListPageNotFound(error, page)) return {
+					items: [],
+					page,
+					expected404Outcome: "end_of_list"
+				};
+				throw error;
+			}
 		}
-	}
-};
-const getRoutineSchema = { routineId: nonEmptyId };
-const getRoutineDefinition = {
-	name: "get-routine",
-	feature: "routines",
-	operation: "get",
-	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 }) => {
-		try {
+	},
+	{
+		name: "get-routine",
+		feature: "routines",
+		operation: "get",
+		description: "Read-only. Gets one routine with exercises and sets by routine_id. Use search-routines to discover IDs.",
+		inputSchema: { routine_id: nonEmptyId },
+		kind: "read",
+		outputSchema: routineResponse.outputSchema,
+		annotations: readOnlyAnnotations("Get Routine"),
+		responseContract: routineResponse,
+		execute: async (runtime, { routine_id }) => {
+			try {
+				return {
+					routine: (await runtime.getClient().getRoutineById(String(routine_id)))?.routine,
+					routine_id
+				};
+			} catch (error) {
+				if (isExpectedReadNotFound(error)) return {
+					routine: null,
+					routine_id,
+					expected404Outcome: "not_found"
+				};
+				throw error;
+			}
+		}
+	},
+	{
+		name: "create-routine",
+		feature: "routines",
+		operation: "create",
+		description: "Writes a reusable routine; use create-workout for completed sessions. Retries can create duplicates.",
+		inputSchema: createRoutineInputShape,
+		kind: "write",
+		annotations: createAnnotations("Create Routine"),
+		responseContract: createRoutineResponse,
+		execute: async (runtime, args) => {
+			const { payload, usesRepRanges } = buildRoutinePayload(args.routine, "create");
 			return {
-				routine: (await runtime.getClient().getRoutineById(String(routineId)))?.routine,
-				routineId
-			};
-		} catch (error) {
-			if (isExpectedReadNotFound(error)) return {
-				routine: null,
-				routineId,
-				expected404Outcome: "not_found"
+				routine: await runtime.getClient().createRoutine({ routine: payload }),
+				usesRepRanges
 			};
-			throw error;
 		}
-	}
-};
-const routineExercisesSchema = z.preprocess(parseJsonArray, z.array(z.object(routineExerciseShape)));
-const createRoutineSchema = routinePayloadShape;
-const createRoutineDefinition = {
-	name: "create-routine",
-	feature: "routines",
-	operation: "create",
-	description: describeTool({
-		summary: "Writes to the Hevy account by creating a new workout routine.",
-		aliases: [
-			"add routine",
-			"build workout plan",
-			"save training template"
-		],
-		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."
-	}),
-	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",
 		feature: "routines",
 		operation: "update",
-		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,
+		description: "Mutates a routine by replacing its title and exercises. Omitted exercises are removed.",
+		inputSchema: updateRoutineInputShape,
 		kind: "write",
 		annotations: updateAnnotations("Update Routine"),
 		responseContract: updateRoutineResponse,
 		execute: async (runtime, args) => {
-			const { routineId } = args;
-			const { payload, usesRepRanges } = buildRoutinePayload(args, "update");
+			const { routine_id } = args;
+			const { payload, usesRepRanges } = buildRoutinePayload(args.routine, "update");
 			return {
-				routine: await runtime.getClient().updateRoutine(routineId, { routine: payload }),
-				routineId,
+				routine: await runtime.getClient().updateRoutine(routine_id, { routine: payload }),
+				routine_id,
 				usesRepRanges
 			};
 		}
@@ -3397,17 +3417,19 @@ const getExerciseTemplatesSchema = paginationShape({
 	defaultPageSize: 5,
 	maxPageSize: 100
 });
-const getExerciseTemplateSchema = { exerciseTemplateId: nonEmptyId };
+const getExerciseTemplateSchema = { exercise_template_id: nonEmptyId };
+const isoDateTimeBase = z.iso.datetime({ offset: true });
+const isoDateTimeWithOffset = z.string().refine((value) => isoDateTimeBase.safeParse(value).success, "Must be an ISO 8601 timestamp with an offset").meta({ format: "date-time" });
 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()
+	exercise_template_id: nonEmptyId,
+	start_date: isoDateTimeWithOffset.optional(),
+	end_date: isoDateTimeWithOffset.optional()
 };
 const createExerciseTemplateSchema = exerciseTemplateInputShape;
 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")
+	query: z.string().min(1),
+	primary_muscle_group: muscleGroupEnum.optional(),
+	refresh: z.boolean().optional().default(false)
 };
 /** Ordered exercise-template tools for composition by the shared server. */
 const templateToolDefinitions = [
@@ -3415,27 +3437,18 @@ const templateToolDefinitions = [
 		name: "get-exercise-templates",
 		feature: "templates",
 		operation: "list",
-		description: describeTool({
-			summary: "Read-only. Lists default and custom exercise templates with equipment and muscle metadata.",
-			aliases: [
-				"browse exercises",
-				"list exercise catalog",
-				"show movements"
-			],
-			useCase: "Use for page-by-page catalog browsing; use search-exercise-templates for a name lookup across the full catalog.",
-			importantNotes: "Results are paginated; page starts at 1 and pageSize is limited to 100."
-		}),
+		description: "Read-only. Pages through exercise templates. Use search-exercise-templates when a title is known.",
 		inputSchema: getExerciseTemplatesSchema,
 		outputSchema: exerciseTemplatesResponse.outputSchema,
 		annotations: readOnlyAnnotations("Get Exercise Templates"),
 		kind: "read",
 		responseContract: exerciseTemplatesResponse,
 		execute: async (runtime, args) => {
-			const { page, pageSize } = args;
+			const { page, page_size } = args;
 			try {
 				const data = await runtime.getClient().getExerciseTemplates({
 					page,
-					pageSize
+					pageSize: page_size
 				});
 				return {
 					items: data?.exercise_templates ?? [],
@@ -3456,32 +3469,23 @@ const templateToolDefinitions = [
 		name: "get-exercise-template",
 		feature: "templates",
 		operation: "get",
-		description: describeTool({
-			summary: "Read-only. Retrieves complete metadata for one exercise template by ID.",
-			aliases: [
-				"show exercise details",
-				"fetch movement",
-				"exercise template info"
-			],
-			useCase: "Use after locating an exact template; use search-exercise-templates when only a name is known.",
-			importantNotes: "Requires an exerciseTemplateId from a template list, search, routine, or workout."
-		}),
+		description: "Read-only. Gets one exercise template by exercise_template_id. Use search-exercise-templates to discover IDs.",
 		inputSchema: getExerciseTemplateSchema,
 		outputSchema: exerciseTemplateResponse.outputSchema,
 		annotations: readOnlyAnnotations("Get Exercise Template"),
 		kind: "read",
 		responseContract: exerciseTemplateResponse,
 		execute: async (runtime, args) => {
-			const { exerciseTemplateId } = args;
+			const { exercise_template_id } = args;
 			try {
 				return {
-					exerciseTemplate: await runtime.getClient().getExerciseTemplate(exerciseTemplateId),
-					exerciseTemplateId
+					exercise_template: await runtime.getClient().getExerciseTemplate(exercise_template_id),
+					exercise_template_id
 				};
 			} catch (error) {
 				if (isExpectedReadNotFound(error)) return {
-					exerciseTemplate: null,
-					exerciseTemplateId,
+					exercise_template: null,
+					exercise_template_id,
 					expected404Outcome: "not_found"
 				};
 				throw error;
@@ -3492,29 +3496,20 @@ const templateToolDefinitions = [
 		name: "get-exercise-history",
 		feature: "templates",
 		operation: "get",
-		description: describeTool({
-			summary: "Read-only. Retrieves past performed sets for one exercise template.",
-			aliases: [
-				"exercise progress",
-				"past sets",
-				"movement history"
-			],
-			useCase: "Use to analyze performance for one movement; use get-workouts for complete sessions.",
-			importantNotes: "Requires an exerciseTemplateId. Optional startDate and endDate must be ISO 8601 datetimes with an offset."
-		}),
+		description: "Read-only. Returns performed sets for one exercise-template ID, optionally bounded by ISO 8601 timestamps.",
 		inputSchema: getExerciseHistorySchema,
 		outputSchema: exerciseHistoryResponse.outputSchema,
 		annotations: readOnlyAnnotations("Get Exercise History"),
 		kind: "read",
 		responseContract: exerciseHistoryResponse,
 		execute: async (runtime, args) => {
-			const { exerciseTemplateId, startDate, endDate } = args;
+			const { exercise_template_id, start_date, end_date } = args;
 			return {
-				history: (await runtime.getClient().getExerciseHistory(exerciseTemplateId, {
-					...startDate ? { start_date: startDate } : {},
-					...endDate ? { end_date: endDate } : {}
+				exercise_history: (await runtime.getClient().getExerciseHistory(exercise_template_id, {
+					...start_date ? { start_date } : {},
+					...end_date ? { end_date } : {}
 				}))?.exercise_history,
-				exerciseTemplateId
+				exercise_template_id
 			};
 		}
 	},
@@ -3522,38 +3517,20 @@ const templateToolDefinitions = [
 		name: "create-exercise-template",
 		feature: "templates",
 		operation: "create",
-		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."
-		}),
+		description: "Writes a custom exercise template. Search first; retries or reused titles can create duplicates.",
 		inputSchema: createExerciseTemplateSchema,
 		annotations: createAnnotations("Create Exercise Template"),
 		kind: "write",
 		responseContract: createExerciseTemplateResponse,
 		execute: async (runtime, args) => {
-			return runtime.getClient().createExerciseTemplate(buildExerciseTemplateRequest(args));
+			return runtime.getClient().createExerciseTemplate(args);
 		}
 	},
 	{
 		name: "search-exercise-templates",
 		feature: "templates",
 		operation: "search",
-		description: describeTool({
-			summary: "Read-only for the Hevy account. Searches the full exercise template catalog by title substring.",
-			aliases: [
-				"find exercise",
-				"look up movement",
-				"search exercise IDs"
-			],
-			useCase: "Use when a name or partial name is known, especially to discover IDs for workouts and routines; use get-exercise-templates for page browsing.",
-			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."
-		}),
+		description: "Read-only. Searches template titles case-insensitively and returns IDs. refresh reloads the five-minute catalog cache.",
 		inputSchema: searchExerciseTemplatesSchema,
 		outputSchema: searchExerciseTemplatesResponse.outputSchema,
 		annotations: readOnlyAnnotations("Search Exercise Templates"),
@@ -3561,7 +3538,7 @@ const templateToolDefinitions = [
 		responseContract: searchExerciseTemplatesResponse,
 		execute: async (runtime, args) => {
 			runtime.getClient();
-			const { query, primaryMuscleGroup, refresh } = args;
+			const { query, primary_muscle_group, refresh } = args;
 			const templates = await runtime.catalog.get({
 				refresh,
 				onRefreshed: (refreshedCatalog, reason) => {
@@ -3582,11 +3559,11 @@ const templateToolDefinitions = [
 			});
 			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 (primary_muscle_group !== void 0) results = results.filter((t) => t.primary_muscle_group === primary_muscle_group);
 			return {
 				results,
 				query,
-				primaryMuscleGroup
+				primary_muscle_group
 			};
 		}
 	}
@@ -3595,16 +3572,7 @@ const userToolDefinitions = [{
 	name: "get-user-info",
 	feature: "profile",
 	operation: "get",
-	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."
-	}),
+	description: "Read-only. Returns the authenticated Hevy user ID, display name, and public profile URL.",
 	inputSchema: {},
 	kind: "read",
 	outputSchema: userResponse.outputSchema,
@@ -3617,8 +3585,8 @@ const userToolDefinitions = [{
 //#endregion
 //#region ../core/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).")
+	query: z.string().min(1).optional(),
+	limit: z.coerce.number().int().min(1).max(100).default(20)
 };
 async function discoverRoutines(runtime, { query, limit }) {
 	const normalizedQuery = query?.toLocaleLowerCase();
@@ -3645,14 +3613,7 @@ async function discoverRoutines(runtime, { query, limit }) {
 		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
-		})),
+		routines: routines.slice(0, limit).map(summarizeRoutine),
 		workflow: {
 			name: "routine-discovery",
 			pagination: { routines: pages },
@@ -3665,16 +3626,7 @@ const routineDiscoveryToolDefinitions = [{
 	name: "search-routines",
 	feature: "workflows",
 	operation: "search",
-	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."
-	}),
+	description: "Read-only. Searches routine titles and returns compact IDs and counts. Use get-routine for full exercises and sets.",
 	inputSchema: routineDiscoverySchema,
 	outputSchema: compactRoutinesResponse.outputSchema,
 	annotations: readOnlyAnnotations("Search Routines"),
@@ -3684,7 +3636,7 @@ const routineDiscoveryToolDefinitions = [{
 }];
 //#endregion
 //#region ../core/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 trainingSummarySchema = { weeks: z.coerce.number().int().min(1).max(12).default(4) };
 const MILLISECONDS_PER_DAY = 1440 * 60 * 1e3;
 function parseUtcDate(value) {
 	const normalized = value.length === 10 ? `${value}T00:00:00.000Z` : value;
@@ -3738,28 +3690,29 @@ function getPeriod(weeks) {
 	};
 }
 function durationSeconds(workout) {
-	if (!workout.start_time || !workout.end_time) return null;
+	if (!workout.start_time || !workout.end_time) return void 0;
 	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;
+	return Number.isFinite(duration) && duration >= 0 ? Math.floor(duration / 1e3) : void 0;
 }
 function compactSession(workout) {
 	const exercises = workout.exercises ?? [];
+	const elapsedSeconds = durationSeconds(workout);
 	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)
+		...workout.start_time ? { start_time: workout.start_time } : {},
+		...workout.end_time ? { end_time: workout.end_time } : {},
+		...elapsedSeconds === void 0 ? {} : { duration_seconds: elapsedSeconds },
+		exercise_count: exercises.length,
+		set_count: exercises.reduce((total, exercise) => total + (exercise.sets?.length ?? 0), 0)
 	};
 }
 function compactMeasurement(measurement) {
 	return {
 		date: measurement.date,
-		weightKg: measurement.weight_kg ?? null,
-		leanMassKg: measurement.lean_mass_kg ?? null,
-		fatPercent: measurement.fat_percent ?? null
+		...measurement.weight_kg == null ? {} : { weight_kg: measurement.weight_kg },
+		...measurement.lean_mass_kg == null ? {} : { lean_mass_kg: measurement.lean_mass_kg },
+		...measurement.fat_percent == null ? {} : { fat_percent: measurement.fat_percent }
 	};
 }
 async function getTrainingSummary(runtime, weeks) {
@@ -3787,37 +3740,38 @@ async function getTrainingSummary(runtime, weeks) {
 	}, 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 unique_exercise_template_ids = [...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;
+	const earliest = earliestMeasurement ? compactMeasurement(earliestMeasurement) : void 0;
+	const latest = latestMeasurement ? compactMeasurement(latestMeasurement) : void 0;
+	const weight_change_kg = latest?.weight_kg !== void 0 && earliest?.weight_kg !== void 0 ? latest.weight_kg - earliest.weight_kg : void 0;
 	return {
 		period: {
-			...period,
+			start_date: period.startDate,
+			end_date: period.endDate,
 			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,
+			total_duration_seconds: sessions.reduce((total, session) => total + (session.duration_seconds ?? 0), 0),
+			exercise_count: sessions.reduce((total, session) => total + session.exercise_count, 0),
+			set_count: sessions.reduce((total, session) => total + session.set_count, 0),
+			unique_exercise_template_ids,
 			sessions
 		},
-		bodyMeasurements: {
+		body_measurements: {
 			count: measurements.length,
-			latest,
-			earliest,
-			weightChangeKg
+			...latest ? { latest } : {},
+			...earliest ? { earliest } : {},
+			...weight_change_kg === void 0 ? {} : { weight_change_kg }
 		},
 		workflow: {
 			name: "training-summary",
 			pagination: {
 				workouts: workoutPages.pages,
-				bodyMeasurements: measurementPages.pages
+				body_measurements: measurementPages.pages
 			},
 			cacheStatus: "not-used",
 			itemsScanned: workoutPages.itemsScanned + measurementPages.itemsScanned
@@ -3828,16 +3782,7 @@ const workflowToolDefinitions = [{
 	name: "get-training-summary",
 	feature: "workflows",
 	operation: "get",
-	description: describeTool({
-		summary: "Read-only. Summarizes recent workout activity and body-measurement trends in one call.",
-		aliases: [
-			"training progress",
-			"progress summary",
-			"recent training overview"
-		],
-		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."
-	}),
+	description: "Read-only. Summarizes workouts and body-measurement trends for the last 1–12 weeks, including compact session and scan evidence.",
 	inputSchema: trainingSummarySchema,
 	outputSchema: trainingSummaryResponse.outputSchema,
 	annotations: readOnlyAnnotations("Get Training Summary"),
@@ -3852,7 +3797,7 @@ const getWorkoutsSchema = paginationShape({
 	maxPageSize: 10,
 	integerPage: false
 });
-const getWorkoutSchema = { workoutId: nonEmptyId };
+const getWorkoutSchema = { workout_id: nonEmptyId };
 const getWorkoutEventsSchema = {
 	...paginationShape({
 		defaultPageSize: 5,
@@ -3860,11 +3805,9 @@ const getWorkoutEventsSchema = {
 	}),
 	since: z.string().default("1970-01-01T00:00:00Z")
 };
-const createWorkoutSchema = workoutPayloadShape;
-const updateWorkoutSchema = {
-	workoutId: nonEmptyId,
-	...workoutPayloadShape
-};
+const createWorkoutSchema = workoutInputShape;
+const updateWorkoutSchema = updateWorkoutInputShape;
+const replaceWorkoutExercisesSchema = replaceWorkoutExercisesInputShape;
 //#endregion
 //#region ../core/src/tools/register.ts
 const hevyToolDefinitions = [
@@ -3873,16 +3816,7 @@ const hevyToolDefinitions = [
 			name: "get-workouts",
 			feature: "workouts",
 			operation: "list",
-			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."
-			}),
+			description: "Read-only. Lists compact workout summaries newest first. Use get-workout for exercises and sets; results are paginated.",
 			inputSchema: getWorkoutsSchema,
 			outputSchema: workoutsResponse.outputSchema,
 			annotations: readOnlyAnnotations("Get Workouts"),
@@ -3892,7 +3826,7 @@ const hevyToolDefinitions = [
 				try {
 					const data = await runtime.getClient().getWorkouts({
 						page: args.page,
-						pageSize: args.pageSize
+						pageSize: args.page_size
 					});
 					return {
 						items: data?.workouts ?? [],
@@ -3913,16 +3847,7 @@ const hevyToolDefinitions = [
 			name: "get-workout",
 			feature: "workouts",
 			operation: "get",
-			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."
-			}),
+			description: "Read-only. Gets one workout with exercises and sets by workout_id. Use get-workouts to discover IDs.",
 			inputSchema: getWorkoutSchema,
 			outputSchema: workoutResponse.outputSchema,
 			annotations: readOnlyAnnotations("Get Workout"),
@@ -3931,13 +3856,13 @@ const hevyToolDefinitions = [
 			execute: async (runtime, args) => {
 				try {
 					return {
-						workout: await runtime.getClient().getWorkout(args.workoutId),
-						workoutId: args.workoutId
+						workout: await runtime.getClient().getWorkout(args.workout_id),
+						workout_id: args.workout_id
 					};
 				} catch (error) {
 					if (isExpectedReadNotFound(error)) return {
 						workout: null,
-						workoutId: args.workoutId,
+						workout_id: args.workout_id,
 						expected404Outcome: "not_found"
 					};
 					throw error;
@@ -3948,16 +3873,7 @@ const hevyToolDefinitions = [
 			name: "get-workout-count",
 			feature: "workouts",
 			operation: "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."
-			}),
+			description: "Read-only. Returns the total workout count; it does not return records or accept date filters.",
 			inputSchema: {},
 			outputSchema: workoutCountResponse.outputSchema,
 			annotations: readOnlyAnnotations("Get Workout Count"),
@@ -3971,16 +3887,7 @@ const hevyToolDefinitions = [
 			name: "get-workout-events",
 			feature: "workouts",
 			operation: "sync",
-			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."
-			}),
+			description: "Read-only. Lists workout update and deletion events since a timestamp for incremental sync; results are paginated.",
 			inputSchema: getWorkoutEventsSchema,
 			outputSchema: workoutEventsResponse.outputSchema,
 			annotations: readOnlyAnnotations("Get Workout Events"),
@@ -3990,7 +3897,7 @@ const hevyToolDefinitions = [
 				try {
 					const data = await runtime.getClient().getWorkoutEvents({
 						page: args.page,
-						pageSize: args.pageSize,
+						pageSize: args.page_size,
 						since: args.since
 					});
 					return {
@@ -4014,46 +3921,48 @@ const hevyToolDefinitions = [
 			name: "create-workout",
 			feature: "workouts",
 			operation: "create",
-			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."
-			}),
+			description: "Writes a completed workout. Requires exercise-template IDs and UTC times. Retries 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) });
+				return await runtime.getClient().createWorkout({ workout: args.workout });
 			}
 		},
 		{
 			name: "update-workout",
 			feature: "workouts",
 			operation: "update",
-			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."
-			}),
+			description: "Mutates workout metadata by ID. Omitted fields and all exercises remain unchanged.",
 			inputSchema: updateWorkoutSchema,
 			annotations: updateAnnotations("Update Workout"),
 			kind: "write",
 			responseContract: updateWorkoutResponse,
 			execute: async (runtime, args) => {
+				const client = runtime.getClient();
+				const payload = buildWorkoutUpdatePayload(await client.getWorkout(args.workout_id), args.workout);
 				return {
-					workout: await runtime.getClient().updateWorkout(args.workoutId, { workout: buildWorkoutPayload(args) }),
-					workoutId: args.workoutId
+					workout: await client.updateWorkout(args.workout_id, { workout: payload }),
+					workout_id: args.workout_id
+				};
+			}
+		},
+		{
+			name: "replace-workout-exercises",
+			feature: "workouts",
+			operation: "update",
+			description: "Mutates a workout by replacing all exercises and sets. Workout metadata remains unchanged.",
+			inputSchema: replaceWorkoutExercisesSchema,
+			annotations: updateAnnotations("Replace Workout Exercises"),
+			kind: "write",
+			responseContract: updateWorkoutResponse,
+			execute: async (runtime, args) => {
+				const client = runtime.getClient();
+				const payload = buildWorkoutUpdatePayload(await client.getWorkout(args.workout_id), {}, args.workout.exercises);
+				return {
+					workout: await client.updateWorkout(args.workout_id, { workout: payload }),
+					workout_id: args.workout_id
 				};
 			}
 		}
@@ -4132,55 +4041,59 @@ function withErrorHandling(fn, context, onError) {
 }
 //#endregion
 //#region ../core/src/tools/tool-runtime.ts
-const STRUCTURAL_ARGUMENT_KEYS = [
-	"page",
-	"pageSize",
-	"since",
-	"workoutId",
-	"routineId",
-	"folderId",
-	"exerciseTemplateId",
-	"date",
-	"startDate",
-	"endDate",
-	"updatedSince",
-	"includeCustom",
-	"limit",
-	"offset",
-	"refresh",
-	"query",
-	"primaryMuscleGroup"
-];
-const PRESENCE_ARGUMENT_KEYS = /* @__PURE__ */ new Set([
-	"since",
-	"workoutId",
-	"routineId",
-	"folderId",
-	"exerciseTemplateId",
-	"date",
-	"startDate",
-	"endDate",
-	"updatedSince",
-	"query",
-	"primaryMuscleGroup"
-]);
-const NUMERIC_ARGUMENT_KEYS = /* @__PURE__ */ new Set([
-	"page",
-	"pageSize",
-	"limit",
-	"offset"
-]);
-const BOOLEAN_ARGUMENT_KEYS = /* @__PURE__ */ new Set(["includeCustom", "refresh"]);
+const STRUCTURAL_ARGUMENT_KEYS = {
+	page: true,
+	page_size: true,
+	since: true,
+	workout_id: true,
+	routine_id: true,
+	folder_id: true,
+	exercise_template_id: true,
+	date: true,
+	start_date: true,
+	end_date: true,
+	updated_since: true,
+	include_custom: true,
+	limit: true,
+	offset: true,
+	refresh: true,
+	query: true,
+	primary_muscle_group: true
+};
+const PRESENCE_ARGUMENT_KEYS = {
+	since: true,
+	workout_id: true,
+	routine_id: true,
+	folder_id: true,
+	exercise_template_id: true,
+	date: true,
+	start_date: true,
+	end_date: true,
+	updated_since: true,
+	query: true,
+	primary_muscle_group: true
+};
+const NUMERIC_ARGUMENT_KEYS = {
+	page: true,
+	page_size: true,
+	limit: true,
+	offset: true
+};
+const BOOLEAN_ARGUMENT_KEYS = {
+	include_custom: true,
+	refresh: true
+};
+const structuralArgumentKeys = Object.keys(STRUCTURAL_ARGUMENT_KEYS);
 function createSafeInvocation(name, args, taxonomy) {
-	const argumentKeys = STRUCTURAL_ARGUMENT_KEYS.filter((key) => key in args);
+	const argumentKeys = structuralArgumentKeys.filter((key) => key in args);
 	const argumentPresence = {};
 	const numericArgumentBuckets = {};
 	const booleanArguments = {};
 	for (const key of argumentKeys) {
 		const value = args[key];
-		if (PRESENCE_ARGUMENT_KEYS.has(key) && value !== null && value !== void 0) argumentPresence[key] = true;
-		if (NUMERIC_ARGUMENT_KEYS.has(key) && typeof value === "number") numericArgumentBuckets[key] = bucketCount(value);
-		if (BOOLEAN_ARGUMENT_KEYS.has(key) && typeof value === "boolean") booleanArguments[key] = value;
+		if (key in PRESENCE_ARGUMENT_KEYS && value !== null && value !== void 0) argumentPresence[key] = true;
+		if (key in NUMERIC_ARGUMENT_KEYS && typeof value === "number") numericArgumentBuckets[key] = bucketCount(value);
+		if (key in BOOLEAN_ARGUMENT_KEYS && typeof value === "boolean") booleanArguments[key] = value;
 	}
 	return {
 		name,