hevy-mcp 1.17.2 → 1.18.0

package/dist/src-BqxJlq7j.mjs

@@ -0,0 +1,1440 @@
+#!/usr/bin/env node
+// Generated with tsdown
+// https://tsdown.dev
+;{try{(function(){var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="a4412ce9-ddb4-48ee-be98-0cda1fedb287",e._sentryDebugIdIdentifier="sentry-dbid-a4412ce9-ddb4-48ee-be98-0cda1fedb287");})();}catch(e){}};!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{};e.SENTRY_RELEASE={id:"1.17.3"};}catch(e){}}();import dotenvx from "@dotenvx/dotenvx";
+import * as Sentry from "@sentry/node";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import axios from "axios";
+import fetch from "@kubb/plugin-client/clients/axios";
+
+//#region src/utils/error-handler.ts
+/**
+* Specific error types for better categorization
+*/
+let ErrorType = /* @__PURE__ */ function(ErrorType$1) {
+	ErrorType$1["API_ERROR"] = "API_ERROR";
+	ErrorType$1["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+	ErrorType$1["NOT_FOUND"] = "NOT_FOUND";
+	ErrorType$1["NETWORK_ERROR"] = "NETWORK_ERROR";
+	ErrorType$1["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+	return ErrorType$1;
+}({});
+/**
+* Create a standardized error response for MCP tools
+*
+* @param error - The error object or message
+* @param context - Optional context information about where the error occurred
+* @returns A formatted MCP tool response with error information
+*/
+function createErrorResponse(error, context) {
+	const errorMessage = error instanceof Error ? error.message : String(error);
+	const errorCode = error instanceof Error && "code" in error ? error.code : void 0;
+	const errorType = determineErrorType(error, errorMessage);
+	if (errorCode) console.debug(`Error code: ${errorCode}`);
+	const formattedMessage = `${context ? `[${context}] ` : ""}Error: ${errorMessage}`;
+	console.error(`${formattedMessage} (Type: ${errorType})`, error);
+	return {
+		content: [{
+			type: "text",
+			text: formattedMessage
+		}],
+		isError: true
+	};
+}
+/**
+* Determine the type of error based on error characteristics
+*/
+function determineErrorType(error, message) {
+	const messageLower = message.toLowerCase();
+	const nameLower = error instanceof Error ? error.name.toLowerCase() : "";
+	if (nameLower.includes("network") || messageLower.includes("network") || nameLower.includes("fetch") || messageLower.includes("fetch") || nameLower.includes("timeout") || messageLower.includes("timeout")) return ErrorType.NETWORK_ERROR;
+	if (nameLower.includes("validation") || messageLower.includes("validation") || messageLower.includes("invalid") || messageLower.includes("required")) return ErrorType.VALIDATION_ERROR;
+	if (messageLower.includes("not found") || messageLower.includes("404") || messageLower.includes("does not exist")) return ErrorType.NOT_FOUND;
+	if (nameLower.includes("api") || messageLower.includes("api") || messageLower.includes("server error") || messageLower.includes("500")) return ErrorType.API_ERROR;
+	return ErrorType.UNKNOWN_ERROR;
+}
+/**
+* Wrap an async function with standardized error handling
+*
+* This function preserves the parameter types of the wrapped function while
+* providing error handling. The returned function accepts Record<string, unknown>
+* (as required by MCP SDK) but internally casts to the original parameter type.
+*
+* @param fn - The async function to wrap
+* @param context - Context information for error messages
+* @returns A function that catches errors and returns standardized error responses
+*/
+function withErrorHandling(fn, context) {
+	return async (args) => {
+		try {
+			return await fn(args);
+		} catch (error) {
+			return createErrorResponse(error, context);
+		}
+	};
+}
+
+//#endregion
+//#region src/utils/formatters.ts
+/**
+* Format a workout object for consistent presentation
+*
+* @param workout - The workout object from the API
+* @returns A formatted workout object with standardized properties
+*/
+function formatWorkout(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,
+		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: exercise.supersets_id,
+				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
+				}))
+			};
+		})
+	};
+}
+/**
+* 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) {
+	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: exercise.supersets_id,
+				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
+				}))
+			};
+		})
+	};
+}
+/**
+* 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) {
+	return {
+		id: folder.id,
+		title: folder.title,
+		createdAt: folder.created_at,
+		updatedAt: 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 {
+		const start = new Date(startTime);
+		const end = new Date(endTime);
+		if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime())) return "Unknown duration";
+		const durationMs = end.getTime() - start.getTime();
+		if (durationMs < 0) return "Invalid duration (end time before start time)";
+		return `${Math.floor(durationMs / (1e3 * 60 * 60))}h ${Math.floor(durationMs % (1e3 * 60 * 60) / (1e3 * 60))}m ${Math.floor(durationMs % (1e3 * 60) / 1e3)}s`;
+	} catch (error) {
+		console.error("Error calculating duration:", error);
+		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) {
+	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
+	};
+}
+
+//#endregion
+//#region src/utils/response-formatter.ts
+/**
+* Create a standardized success response with JSON data
+*
+* @param data - The data to include in the response
+* @param options - Formatting options
+* @returns A formatted MCP tool response with the data as JSON
+*/
+function createJsonResponse(data, options = {
+	pretty: true,
+	indent: 2
+}) {
+	return { content: [{
+		type: "text",
+		text: options.pretty ? JSON.stringify(data, null, options.indent) : JSON.stringify(data)
+	}] };
+}
+/**
+* Create a standardized success response for empty or null results
+*
+* @param message - Optional message to include (default: "No data found")
+* @returns A formatted MCP tool response for empty results
+*/
+function createEmptyResponse(message = "No data found") {
+	return { content: [{
+		type: "text",
+		text: message
+	}] };
+}
+
+//#endregion
+//#region src/tools/folders.ts
+/**
+* Register all routine folder-related tools with the MCP server
+*/
+function registerFolderTools(server, hevyClient) {
+	const getRoutineFoldersSchema = {
+		page: z.coerce.number().int().gte(1).default(1),
+		pageSize: z.coerce.number().int().gte(1).lte(10).default(5)
+	};
+	server.tool("get-routine-folders", "Get a paginated list of your routine folders, including both default and custom folders. Useful for organizing and browsing your workout routines.", getRoutineFoldersSchema, withErrorHandling(async (args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		const { page, pageSize } = args;
+		const folders = (await hevyClient.getRoutineFolders({
+			page,
+			pageSize
+		}))?.routine_folders?.map((folder) => formatRoutineFolder(folder)) || [];
+		if (folders.length === 0) return createEmptyResponse("No routine folders found for the specified parameters");
+		return createJsonResponse(folders);
+	}, "get-routine-folders"));
+	const getRoutineFolderSchema = { folderId: z.string().min(1) };
+	server.tool("get-routine-folder", "Get complete details of a specific routine folder by its ID, including name, creation date, and associated routines.", getRoutineFolderSchema, withErrorHandling(async (args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		const { folderId } = args;
+		const data = await hevyClient.getRoutineFolder(folderId);
+		if (!data) return createEmptyResponse(`Routine folder with ID ${folderId} not found`);
+		return createJsonResponse(formatRoutineFolder(data));
+	}, "get-routine-folder"));
+	const createRoutineFolderSchema = { name: z.string().min(1) };
+	server.tool("create-routine-folder", "Create a new routine folder in your Hevy account. Requires a name for the folder. Returns the full folder details including the new folder ID.", createRoutineFolderSchema, withErrorHandling(async (args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		const { name: name$1 } = args;
+		const data = await hevyClient.createRoutineFolder({ routine_folder: { title: name$1 } });
+		if (!data) return createEmptyResponse("Failed to create routine folder: Server returned no data");
+		return createJsonResponse(formatRoutineFolder(data), {
+			pretty: true,
+			indent: 2
+		});
+	}, "create-routine-folder"));
+}
+
+//#endregion
+//#region src/tools/routines.ts
+/**
+* Register all routine-related tools with the MCP server
+*/
+function registerRoutineTools(server, hevyClient) {
+	const getRoutinesSchema = {
+		page: z.coerce.number().int().gte(1).default(1),
+		pageSize: z.coerce.number().int().gte(1).lte(10).default(5)
+	};
+	server.tool("get-routines", "Get a paginated list of your workout routines, including custom and default routines. Useful for browsing or searching your available routines.", getRoutinesSchema, withErrorHandling(async (args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		const { page, pageSize } = args;
+		const routines = (await hevyClient.getRoutines({
+			page,
+			pageSize
+		}))?.routines?.map((routine) => formatRoutine(routine)) || [];
+		if (routines.length === 0) return createEmptyResponse("No routines found for the specified parameters");
+		return createJsonResponse(routines);
+	}, "get-routines"));
+	const getRoutineSchema = { routineId: z.string().min(1) };
+	server.tool("get-routine", "Get a routine by its ID using the direct endpoint. Returns all details for the specified routine.", getRoutineSchema, withErrorHandling(async (args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		const { routineId } = args;
+		const data = await hevyClient.getRoutineById(String(routineId));
+		if (!data || !data.routine) return createEmptyResponse(`Routine with ID ${routineId} not found`);
+		return createJsonResponse(formatRoutine(data.routine));
+	}, "get-routine"));
+	const createRoutineSchema = {
+		title: z.string().min(1),
+		folderId: z.coerce.number().nullable().optional(),
+		notes: z.string().optional(),
+		exercises: z.array(z.object({
+			exerciseTemplateId: z.string().min(1),
+			supersetId: z.coerce.number().nullable().optional(),
+			restSeconds: z.coerce.number().int().min(0).optional(),
+			notes: z.string().optional(),
+			sets: z.array(z.object({
+				type: z.enum([
+					"warmup",
+					"normal",
+					"failure",
+					"dropset"
+				]).default("normal"),
+				weight: z.coerce.number().optional(),
+				weightKg: z.coerce.number().optional(),
+				reps: z.coerce.number().int().optional(),
+				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: z.object({
+					start: z.coerce.number().int().optional(),
+					end: z.coerce.number().int().optional()
+				}).optional()
+			}))
+		}))
+	};
+	server.tool("create-routine", "Create a new workout routine in your Hevy account. Requires a title and at least one exercise with sets. Optionally assign to a folder. Returns the full routine details including the new routine ID.", createRoutineSchema, withErrorHandling(async (args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		const { title, folderId, notes, exercises } = args;
+		const data = await hevyClient.createRoutine({ routine: {
+			title,
+			folder_id: folderId ?? null,
+			notes: notes ?? "",
+			exercises: exercises.map((exercise) => ({
+				exercise_template_id: exercise.exerciseTemplateId,
+				superset_id: exercise.supersetId ?? null,
+				rest_seconds: exercise.restSeconds ?? 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,
+					custom_metric: set.customMetric ?? null,
+					rep_range: set.repRange ? {
+						start: set.repRange.start ?? null,
+						end: set.repRange.end ?? null
+					} : null
+				}))
+			}))
+		} });
+		if (!data) return createEmptyResponse("Failed to create routine: Server returned no data");
+		return createJsonResponse(formatRoutine(data), {
+			pretty: true,
+			indent: 2
+		});
+	}, "create-routine"));
+	const updateRoutineSchema = {
+		routineId: z.string().min(1),
+		title: z.string().min(1),
+		notes: z.string().optional(),
+		exercises: z.array(z.object({
+			exerciseTemplateId: z.string().min(1),
+			supersetId: z.coerce.number().nullable().optional(),
+			restSeconds: z.coerce.number().int().min(0).optional(),
+			notes: z.string().optional(),
+			sets: z.array(z.object({
+				type: z.enum([
+					"warmup",
+					"normal",
+					"failure",
+					"dropset"
+				]).default("normal"),
+				weight: z.coerce.number().optional(),
+				weightKg: z.coerce.number().optional(),
+				reps: z.coerce.number().int().optional(),
+				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: z.object({
+					start: z.coerce.number().int().optional(),
+					end: z.coerce.number().int().optional()
+				}).optional()
+			}))
+		}))
+	};
+	server.tool("update-routine", "Update an existing routine by ID. You can modify the title, notes, and exercise configurations. Returns the updated routine with all changes applied.", updateRoutineSchema, withErrorHandling(async (args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		const { routineId, title, notes, exercises } = args;
+		const data = await hevyClient.updateRoutine(routineId, { routine: {
+			title,
+			notes: notes ?? null,
+			exercises: exercises.map((exercise) => ({
+				exercise_template_id: exercise.exerciseTemplateId,
+				superset_id: exercise.supersetId ?? null,
+				rest_seconds: exercise.restSeconds ?? 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,
+					custom_metric: set.customMetric ?? null,
+					rep_range: set.repRange ? {
+						start: set.repRange.start ?? null,
+						end: set.repRange.end ?? null
+					} : null
+				}))
+			}))
+		} });
+		if (!data) return createEmptyResponse(`Failed to update routine with ID ${routineId}`);
+		return createJsonResponse(formatRoutine(data), {
+			pretty: true,
+			indent: 2
+		});
+	}, "update-routine"));
+}
+
+//#endregion
+//#region src/tools/templates.ts
+/**
+* Register all exercise template-related tools with the MCP server
+*/
+function registerTemplateTools(server, hevyClient) {
+	const getExerciseTemplatesSchema = {
+		page: z.coerce.number().int().gte(1).default(1),
+		pageSize: z.coerce.number().int().gte(1).lte(100).default(5)
+	};
+	server.tool("get-exercise-templates", "Get a paginated list of exercise templates (default and custom) with details like name, category, equipment, and muscle groups. Useful for browsing or searching available exercises.", getExerciseTemplatesSchema, withErrorHandling(async (args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		const { page, pageSize } = args;
+		const templates = (await hevyClient.getExerciseTemplates({
+			page,
+			pageSize
+		}))?.exercise_templates?.map((template) => formatExerciseTemplate(template)) || [];
+		if (templates.length === 0) return createEmptyResponse("No exercise templates found for the specified parameters");
+		return createJsonResponse(templates);
+	}, "get-exercise-templates"));
+	const getExerciseTemplateSchema = { exerciseTemplateId: z.string().min(1) };
+	server.tool("get-exercise-template", "Get complete details of a specific exercise template by its ID, including name, category, equipment, muscle groups, and notes.", getExerciseTemplateSchema, withErrorHandling(async (args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		const { exerciseTemplateId } = args;
+		const data = await hevyClient.getExerciseTemplate(exerciseTemplateId);
+		if (!data) return createEmptyResponse(`Exercise template with ID ${exerciseTemplateId} not found`);
+		return createJsonResponse(formatExerciseTemplate(data));
+	}, "get-exercise-template"));
+	const getExerciseHistorySchema = {
+		exerciseTemplateId: z.string().min(1),
+		startDate: z.string().datetime({ offset: true }).describe("ISO 8601 start date for filtering history").optional(),
+		endDate: z.string().datetime({ offset: true }).describe("ISO 8601 end date for filtering history").optional()
+	};
+	server.tool("get-exercise-history", "Get past sets for a specific exercise template, optionally filtered by start and end dates.", getExerciseHistorySchema, withErrorHandling(async (args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		const { exerciseTemplateId, startDate, endDate } = args;
+		const history = (await hevyClient.getExerciseHistory(exerciseTemplateId, {
+			...startDate ? { start_date: startDate } : {},
+			...endDate ? { end_date: endDate } : {}
+		}))?.exercise_history?.map((entry) => formatExerciseHistoryEntry(entry)) || [];
+		if (history.length === 0) return createEmptyResponse(`No exercise history found for template ${exerciseTemplateId}`);
+		return createJsonResponse(history);
+	}, "get-exercise-history"));
+	const createExerciseTemplateSchema = {
+		title: z.string().min(1),
+		exerciseType: z.enum([
+			"weight_reps",
+			"reps_only",
+			"bodyweight_reps",
+			"bodyweight_assisted_reps",
+			"duration",
+			"weight_duration",
+			"distance_duration",
+			"short_distance_weight"
+		]),
+		equipmentCategory: z.enum([
+			"none",
+			"barbell",
+			"dumbbell",
+			"kettlebell",
+			"machine",
+			"plate",
+			"resistance_band",
+			"suspension",
+			"other"
+		]),
+		muscleGroup: z.enum([
+			"abdominals",
+			"shoulders",
+			"biceps",
+			"triceps",
+			"forearms",
+			"quadriceps",
+			"hamstrings",
+			"calves",
+			"glutes",
+			"abductors",
+			"adductors",
+			"lats",
+			"upper_back",
+			"traps",
+			"lower_back",
+			"chest",
+			"cardio",
+			"neck",
+			"full_body",
+			"other"
+		]),
+		otherMuscles: z.array(z.enum([
+			"abdominals",
+			"shoulders",
+			"biceps",
+			"triceps",
+			"forearms",
+			"quadriceps",
+			"hamstrings",
+			"calves",
+			"glutes",
+			"abductors",
+			"adductors",
+			"lats",
+			"upper_back",
+			"traps",
+			"lower_back",
+			"chest",
+			"cardio",
+			"neck",
+			"full_body",
+			"other"
+		])).default([])
+	};
+	server.tool("create-exercise-template", "Create a custom exercise template with title, type, equipment, and muscle groups.", createExerciseTemplateSchema, withErrorHandling(async (args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		const { title, exerciseType, equipmentCategory, muscleGroup, otherMuscles } = args;
+		return createJsonResponse({
+			id: (await hevyClient.createExerciseTemplate({ exercise: {
+				title,
+				exercise_type: exerciseType,
+				equipment_category: equipmentCategory,
+				muscle_group: muscleGroup,
+				other_muscles: otherMuscles
+			} }))?.id,
+			message: "Exercise template created successfully"
+		});
+	}, "create-exercise-template"));
+}
+
+//#endregion
+//#region src/tools/webhooks.ts
+const webhookUrlSchema = z.string().url().refine((url) => {
+	try {
+		const parsed = new URL(url);
+		return parsed.protocol === "https:" || parsed.protocol === "http:";
+	} catch {
+		return false;
+	}
+}, { message: "Webhook URL must be a valid HTTP or HTTPS URL" }).refine((url) => {
+	try {
+		const parsed = new URL(url);
+		return parsed.hostname !== "localhost" && !parsed.hostname.startsWith("127.");
+	} catch {
+		return false;
+	}
+}, { message: "Webhook URL cannot be localhost or loopback address" });
+function registerWebhookTools(server, hevyClient) {
+	server.tool("get-webhook-subscription", "Get the current webhook subscription for this account. Returns the webhook URL and auth token if a subscription exists.", {}, withErrorHandling(async (_args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		if (!hevyClient.getWebhookSubscription) throw new Error("Webhook subscription API not available. Please regenerate the client from the updated OpenAPI spec.");
+		const data = await hevyClient.getWebhookSubscription();
+		if (!data) return createEmptyResponse("No webhook subscription found for this account");
+		return createJsonResponse(data);
+	}, "get-webhook-subscription"));
+	const createWebhookSubscriptionSchema = {
+		url: webhookUrlSchema.describe("The webhook URL that will receive POST requests when workouts are created"),
+		authToken: z.string().optional().describe("Optional auth token that will be sent as Authorization header in webhook requests")
+	};
+	server.tool("create-webhook-subscription", "Create a new webhook subscription for this account. The webhook will receive POST requests when workouts are created. Your endpoint must respond with 200 OK within 5 seconds.", createWebhookSubscriptionSchema, withErrorHandling(async (args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		const { url, authToken } = args;
+		if (!hevyClient.createWebhookSubscription) throw new Error("Webhook subscription API not available. Please regenerate the client from the updated OpenAPI spec.");
+		const data = await hevyClient.createWebhookSubscription({ webhook: {
+			url,
+			authToken: authToken || null
+		} });
+		if (!data) return createEmptyResponse("Failed to create webhook subscription - please check your URL and try again");
+		return createJsonResponse(data);
+	}, "create-webhook-subscription"));
+	server.tool("delete-webhook-subscription", "Delete the current webhook subscription for this account. This will stop all webhook notifications.", {}, withErrorHandling(async (_args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		if (!hevyClient.deleteWebhookSubscription) throw new Error("Webhook subscription API not available. Please regenerate the client from the updated OpenAPI spec.");
+		const data = await hevyClient.deleteWebhookSubscription();
+		if (!data) return createEmptyResponse("Failed to delete webhook subscription - no subscription may exist or there was a server error");
+		return createJsonResponse(data);
+	}, "delete-webhook-subscription"));
+}
+
+//#endregion
+//#region src/tools/workouts.ts
+/**
+* Register all workout-related tools with the MCP server
+*/
+function registerWorkoutTools(server, hevyClient) {
+	const getWorkoutsSchema = {
+		page: z.coerce.number().gte(1).default(1),
+		pageSize: z.coerce.number().int().gte(1).lte(10).default(5)
+	};
+	server.tool("get-workouts", "Get a paginated list of workouts. Returns workout details including title, description, start/end times, and exercises performed. Results are ordered from newest to oldest.", getWorkoutsSchema, withErrorHandling(async (args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		const { page, pageSize } = args;
+		const workouts = (await hevyClient.getWorkouts({
+			page,
+			pageSize
+		}))?.workouts?.map((workout) => formatWorkout(workout)) || [];
+		if (workouts.length === 0) return createEmptyResponse("No workouts found for the specified parameters");
+		return createJsonResponse(workouts);
+	}, "get-workouts"));
+	const getWorkoutSchema = { workoutId: z.string().min(1) };
+	server.tool("get-workout", "Get complete details of a specific workout by ID. Returns all workout information including title, description, start/end times, and detailed exercise data.", getWorkoutSchema, withErrorHandling(async (args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		const { workoutId } = args;
+		const data = await hevyClient.getWorkout(workoutId);
+		if (!data) return createEmptyResponse(`Workout with ID ${workoutId} not found`);
+		return createJsonResponse(formatWorkout(data));
+	}, "get-workout"));
+	server.tool("get-workout-count", "Get the total number of workouts on the account. Useful for pagination or statistics.", {}, withErrorHandling(async () => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		const data = await hevyClient.getWorkoutCount();
+		return createJsonResponse({ count: data ? data.workoutCount || 0 : 0 });
+	}, "get-workout-count"));
+	const getWorkoutEventsSchema = {
+		page: z.coerce.number().int().gte(1).default(1),
+		pageSize: z.coerce.number().int().gte(1).lte(10).default(5),
+		since: z.string().default("1970-01-01T00:00:00Z")
+	};
+	server.tool("get-workout-events", "Retrieve a paged list of workout events (updates or deletes) since a given date. Events are ordered from newest to oldest. The intention is to allow clients to keep their local cache of workouts up to date without having to fetch the entire list of workouts.", getWorkoutEventsSchema, withErrorHandling(async (args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		const { page, pageSize, since } = args;
+		const events = (await hevyClient.getWorkoutEvents({
+			page,
+			pageSize,
+			since
+		}))?.events || [];
+		if (events.length === 0) return createEmptyResponse(`No workout events found for the specified parameters since ${since}`);
+		return createJsonResponse(events);
+	}, "get-workout-events"));
+	const createWorkoutSchema = {
+		title: z.string().min(1),
+		description: z.string().optional().nullable(),
+		startTime: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
+		endTime: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
+		routineId: z.string().optional().nullable(),
+		isPrivate: z.boolean().default(false),
+		exercises: z.array(z.object({
+			exerciseTemplateId: z.string().min(1),
+			supersetId: z.coerce.number().nullable().optional(),
+			notes: z.string().optional().nullable(),
+			sets: z.array(z.object({
+				type: z.enum([
+					"warmup",
+					"normal",
+					"failure",
+					"dropset"
+				]).default("normal"),
+				weight: z.coerce.number().optional().nullable(),
+				weightKg: z.coerce.number().optional().nullable(),
+				reps: z.coerce.number().int().optional().nullable(),
+				distance: z.coerce.number().int().optional().nullable(),
+				distanceMeters: z.coerce.number().int().optional().nullable(),
+				duration: z.coerce.number().int().optional().nullable(),
+				durationSeconds: z.coerce.number().int().optional().nullable(),
+				rpe: z.coerce.number().optional().nullable(),
+				customMetric: z.coerce.number().optional().nullable()
+			}))
+		}))
+	};
+	server.tool("create-workout", "Create a new workout in your Hevy account. Requires title, start/end times, and at least one exercise with sets. Returns the complete workout details upon successful creation including the newly assigned workout ID.", createWorkoutSchema, withErrorHandling(async (args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		const { title, description, startTime, endTime, isPrivate, exercises } = args;
+		const requestBody = { workout: {
+			title,
+			description: description || null,
+			start_time: startTime,
+			end_time: endTime,
+			routine_id: args.routineId ?? null,
+			is_private: isPrivate,
+			exercises: exercises.map((exercise) => ({
+				exercise_template_id: exercise.exerciseTemplateId,
+				superset_id: exercise.supersetId ?? null,
+				notes: exercise.notes ?? null,
+				sets: exercise.sets.map((set) => ({
+					type: set.type,
+					weight_kg: set.weight ?? set.weightKg ?? null,
+					reps: set.reps ?? null,
+					distance_meters: set.distance ?? set.distanceMeters ?? null,
+					duration_seconds: set.duration ?? set.durationSeconds ?? null,
+					rpe: set.rpe ?? null,
+					custom_metric: set.customMetric ?? null
+				}))
+			}))
+		} };
+		const data = await hevyClient.createWorkout(requestBody);
+		if (!data) return createEmptyResponse("Failed to create workout: Server returned no data");
+		return createJsonResponse(formatWorkout(data), {
+			pretty: true,
+			indent: 2
+		});
+	}, "create-workout"));
+	const updateWorkoutSchema = {
+		workoutId: z.string().min(1),
+		title: z.string().min(1),
+		description: z.string().optional().nullable(),
+		startTime: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
+		endTime: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
+		routineId: z.string().optional().nullable(),
+		isPrivate: z.boolean().default(false),
+		exercises: z.array(z.object({
+			exerciseTemplateId: z.string().min(1),
+			supersetId: z.coerce.number().nullable().optional(),
+			notes: z.string().optional().nullable(),
+			sets: z.array(z.object({
+				type: z.enum([
+					"warmup",
+					"normal",
+					"failure",
+					"dropset"
+				]).default("normal"),
+				weight: z.coerce.number().optional().nullable(),
+				weightKg: z.coerce.number().optional().nullable(),
+				reps: z.coerce.number().int().optional().nullable(),
+				distance: z.coerce.number().int().optional().nullable(),
+				distanceMeters: z.coerce.number().int().optional().nullable(),
+				duration: z.coerce.number().int().optional().nullable(),
+				durationSeconds: z.coerce.number().int().optional().nullable(),
+				rpe: z.coerce.number().optional().nullable(),
+				customMetric: z.coerce.number().optional().nullable()
+			}))
+		}))
+	};
+	server.tool("update-workout", "Update an existing workout by ID. You can modify the title, description, start/end times, privacy setting, and exercise data. Returns the updated workout with all changes applied.", updateWorkoutSchema, withErrorHandling(async (args) => {
+		if (!hevyClient) throw new Error("API client not initialized. Please provide HEVY_API_KEY.");
+		const { workoutId, title, description, startTime, endTime, routineId, isPrivate, exercises } = args;
+		const requestBody = { workout: {
+			title,
+			description: description || null,
+			start_time: startTime,
+			end_time: endTime,
+			routine_id: routineId ?? null,
+			is_private: isPrivate,
+			exercises: exercises.map((exercise) => ({
+				exercise_template_id: exercise.exerciseTemplateId,
+				superset_id: exercise.supersetId ?? null,
+				notes: exercise.notes ?? null,
+				sets: exercise.sets.map((set) => ({
+					type: set.type,
+					weight_kg: set.weight ?? set.weightKg ?? null,
+					reps: set.reps ?? null,
+					distance_meters: set.distance ?? set.distanceMeters ?? null,
+					duration_seconds: set.duration ?? set.durationSeconds ?? null,
+					rpe: set.rpe ?? null,
+					custom_metric: set.customMetric ?? null
+				}))
+			}))
+		} };
+		const data = await hevyClient.updateWorkout(workoutId, requestBody);
+		if (!data) return createEmptyResponse(`Failed to update workout with ID ${workoutId}`);
+		return createJsonResponse(formatWorkout(data), {
+			pretty: true,
+			indent: 2
+		});
+	}, "update-workout-operation"));
+}
+
+//#endregion
+//#region src/utils/config.ts
+/**
+* Parse CLI arguments and environment to derive configuration.
+* Priority order for API key: CLI flag forms > environment variable.
+* Supported CLI arg forms:
+*   --hevy-api-key=KEY
+*   --hevyApiKey=KEY
+*   hevy-api-key=KEY (bare, e.g. when passed after npm start -- )
+*/
+function parseConfig(argv, env) {
+	let apiKey = "";
+	const apiKeyArgPatterns = [
+		/^--hevy-api-key=(.+)$/i,
+		/^--hevyApiKey=(.+)$/i,
+		/^hevy-api-key=(.+)$/i
+	];
+	for (const raw of argv) {
+		for (const pattern of apiKeyArgPatterns) {
+			const m = raw.match(pattern);
+			if (m) {
+				apiKey = m[1];
+				break;
+			}
+		}
+		if (apiKey) break;
+	}
+	if (!apiKey) apiKey = env.HEVY_API_KEY || "";
+	return { apiKey };
+}
+function assertApiKey(apiKey) {
+	if (!apiKey) {
+		console.error("Hevy API key is required. Provide it via the HEVY_API_KEY environment variable or the --hevy-api-key=YOUR_KEY command argument.");
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/generated/client/api/getV1ExerciseHistoryExercisetemplateid.ts
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+function getGetV1ExerciseHistoryExercisetemplateidUrl(exerciseTemplateId) {
+	return {
+		method: "GET",
+		url: `/v1/exercise_history/${exerciseTemplateId}`
+	};
+}
+/**
+* @summary Get exercise history for a specific exercise template
+* {@link /v1/exercise_history/:exerciseTemplateId}
+*/
+async function getV1ExerciseHistoryExercisetemplateid(exerciseTemplateId, headers, params, config = {}) {
+	const { client: request = fetch, ...requestConfig } = config;
+	return (await request({
+		method: "GET",
+		url: getGetV1ExerciseHistoryExercisetemplateidUrl(exerciseTemplateId).url.toString(),
+		params,
+		...requestConfig,
+		headers: {
+			...headers,
+			...requestConfig.headers
+		}
+	})).data;
+}
+
+//#endregion
+//#region src/generated/client/api/getV1ExerciseTemplates.ts
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+function getGetV1ExerciseTemplatesUrl() {
+	return {
+		method: "GET",
+		url: `/v1/exercise_templates`
+	};
+}
+/**
+* @summary Get a paginated list of exercise templates available on the account.
+* {@link /v1/exercise_templates}
+*/
+async function getV1ExerciseTemplates(headers, params, config = {}) {
+	const { client: request = fetch, ...requestConfig } = config;
+	return (await request({
+		method: "GET",
+		url: getGetV1ExerciseTemplatesUrl().url.toString(),
+		params,
+		...requestConfig,
+		headers: {
+			...headers,
+			...requestConfig.headers
+		}
+	})).data;
+}
+
+//#endregion
+//#region src/generated/client/api/getV1ExerciseTemplatesExercisetemplateid.ts
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+function getGetV1ExerciseTemplatesExercisetemplateidUrl(exerciseTemplateId) {
+	return {
+		method: "GET",
+		url: `/v1/exercise_templates/${exerciseTemplateId}`
+	};
+}
+/**
+* @summary Get a single exercise template by id.
+* {@link /v1/exercise_templates/:exerciseTemplateId}
+*/
+async function getV1ExerciseTemplatesExercisetemplateid(exerciseTemplateId, headers, config = {}) {
+	const { client: request = fetch, ...requestConfig } = config;
+	return (await request({
+		method: "GET",
+		url: getGetV1ExerciseTemplatesExercisetemplateidUrl(exerciseTemplateId).url.toString(),
+		...requestConfig,
+		headers: {
+			...headers,
+			...requestConfig.headers
+		}
+	})).data;
+}
+
+//#endregion
+//#region src/generated/client/api/getV1RoutineFolders.ts
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+function getGetV1RoutineFoldersUrl() {
+	return {
+		method: "GET",
+		url: `/v1/routine_folders`
+	};
+}
+/**
+* @summary Get a paginated list of routine folders available on the account.
+* {@link /v1/routine_folders}
+*/
+async function getV1RoutineFolders(headers, params, config = {}) {
+	const { client: request = fetch, ...requestConfig } = config;
+	return (await request({
+		method: "GET",
+		url: getGetV1RoutineFoldersUrl().url.toString(),
+		params,
+		...requestConfig,
+		headers: {
+			...headers,
+			...requestConfig.headers
+		}
+	})).data;
+}
+
+//#endregion
+//#region src/generated/client/api/getV1RoutineFoldersFolderid.ts
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+function getGetV1RoutineFoldersFolderidUrl(folderId) {
+	return {
+		method: "GET",
+		url: `/v1/routine_folders/${folderId}`
+	};
+}
+/**
+* @summary Get a single routine folder by id.
+* {@link /v1/routine_folders/:folderId}
+*/
+async function getV1RoutineFoldersFolderid(folderId, headers, config = {}) {
+	const { client: request = fetch, ...requestConfig } = config;
+	return (await request({
+		method: "GET",
+		url: getGetV1RoutineFoldersFolderidUrl(folderId).url.toString(),
+		...requestConfig,
+		headers: {
+			...headers,
+			...requestConfig.headers
+		}
+	})).data;
+}
+
+//#endregion
+//#region src/generated/client/api/getV1Routines.ts
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+function getGetV1RoutinesUrl() {
+	return {
+		method: "GET",
+		url: `/v1/routines`
+	};
+}
+/**
+* @summary Get a paginated list of routines
+* {@link /v1/routines}
+*/
+async function getV1Routines(headers, params, config = {}) {
+	const { client: request = fetch, ...requestConfig } = config;
+	return (await request({
+		method: "GET",
+		url: getGetV1RoutinesUrl().url.toString(),
+		params,
+		...requestConfig,
+		headers: {
+			...headers,
+			...requestConfig.headers
+		}
+	})).data;
+}
+
+//#endregion
+//#region src/generated/client/api/getV1RoutinesRoutineid.ts
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+function getGetV1RoutinesRoutineidUrl(routineId) {
+	return {
+		method: "GET",
+		url: `/v1/routines/${routineId}`
+	};
+}
+/**
+* @summary Get a routine by its Id
+* {@link /v1/routines/:routineId}
+*/
+async function getV1RoutinesRoutineid(routineId, headers, config = {}) {
+	const { client: request = fetch, ...requestConfig } = config;
+	return (await request({
+		method: "GET",
+		url: getGetV1RoutinesRoutineidUrl(routineId).url.toString(),
+		...requestConfig,
+		headers: {
+			...headers,
+			...requestConfig.headers
+		}
+	})).data;
+}
+
+//#endregion
+//#region src/generated/client/api/getV1Workouts.ts
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+function getGetV1WorkoutsUrl() {
+	return {
+		method: "GET",
+		url: `/v1/workouts`
+	};
+}
+/**
+* @summary Get a paginated list of workouts
+* {@link /v1/workouts}
+*/
+async function getV1Workouts(headers, params, config = {}) {
+	const { client: request = fetch, ...requestConfig } = config;
+	return (await request({
+		method: "GET",
+		url: getGetV1WorkoutsUrl().url.toString(),
+		params,
+		...requestConfig,
+		headers: {
+			...headers,
+			...requestConfig.headers
+		}
+	})).data;
+}
+
+//#endregion
+//#region src/generated/client/api/getV1WorkoutsCount.ts
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+function getGetV1WorkoutsCountUrl() {
+	return {
+		method: "GET",
+		url: `/v1/workouts/count`
+	};
+}
+/**
+* @summary Get the total number of workouts on the account
+* {@link /v1/workouts/count}
+*/
+async function getV1WorkoutsCount(headers, config = {}) {
+	const { client: request = fetch, ...requestConfig } = config;
+	return (await request({
+		method: "GET",
+		url: getGetV1WorkoutsCountUrl().url.toString(),
+		...requestConfig,
+		headers: {
+			...headers,
+			...requestConfig.headers
+		}
+	})).data;
+}
+
+//#endregion
+//#region src/generated/client/api/getV1WorkoutsEvents.ts
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+function getGetV1WorkoutsEventsUrl() {
+	return {
+		method: "GET",
+		url: `/v1/workouts/events`
+	};
+}
+/**
+* @description Returns a paginated array of workout events, indicating updates or deletions.
+* @summary Retrieve a paged list of workout events (updates or deletes) since a given date. Events are ordered from newest to oldest. The intention is to allow clients to keep their local cache of workouts up to date without having to fetch the entire list of workouts.
+* {@link /v1/workouts/events}
+*/
+async function getV1WorkoutsEvents(headers, params, config = {}) {
+	const { client: request = fetch, ...requestConfig } = config;
+	return (await request({
+		method: "GET",
+		url: getGetV1WorkoutsEventsUrl().url.toString(),
+		params,
+		...requestConfig,
+		headers: {
+			...headers,
+			...requestConfig.headers
+		}
+	})).data;
+}
+
+//#endregion
+//#region src/generated/client/api/getV1WorkoutsWorkoutid.ts
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+function getGetV1WorkoutsWorkoutidUrl(workoutId) {
+	return {
+		method: "GET",
+		url: `/v1/workouts/${workoutId}`
+	};
+}
+/**
+* @summary Get a single workout’s complete details by the workoutId
+* {@link /v1/workouts/:workoutId}
+*/
+async function getV1WorkoutsWorkoutid(workoutId, headers, config = {}) {
+	const { client: request = fetch, ...requestConfig } = config;
+	return (await request({
+		method: "GET",
+		url: getGetV1WorkoutsWorkoutidUrl(workoutId).url.toString(),
+		...requestConfig,
+		headers: {
+			...headers,
+			...requestConfig.headers
+		}
+	})).data;
+}
+
+//#endregion
+//#region src/generated/client/api/postV1ExerciseTemplates.ts
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+function getPostV1ExerciseTemplatesUrl() {
+	return {
+		method: "POST",
+		url: `/v1/exercise_templates`
+	};
+}
+/**
+* @summary Create a new custom exercise template.
+* {@link /v1/exercise_templates}
+*/
+async function postV1ExerciseTemplates(headers, data, config = {}) {
+	const { client: request = fetch, ...requestConfig } = config;
+	const requestData = data;
+	return (await request({
+		method: "POST",
+		url: getPostV1ExerciseTemplatesUrl().url.toString(),
+		data: requestData,
+		...requestConfig,
+		headers: {
+			...headers,
+			...requestConfig.headers
+		}
+	})).data;
+}
+
+//#endregion
+//#region src/generated/client/api/postV1RoutineFolders.ts
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+function getPostV1RoutineFoldersUrl() {
+	return {
+		method: "POST",
+		url: `/v1/routine_folders`
+	};
+}
+/**
+* @summary Create a new routine folder. The folder will be created at index 0, and all other folders will have their indexes incremented.
+* {@link /v1/routine_folders}
+*/
+async function postV1RoutineFolders(headers, data, config = {}) {
+	const { client: request = fetch, ...requestConfig } = config;
+	const requestData = data;
+	return (await request({
+		method: "POST",
+		url: getPostV1RoutineFoldersUrl().url.toString(),
+		data: requestData,
+		...requestConfig,
+		headers: {
+			...headers,
+			...requestConfig.headers
+		}
+	})).data;
+}
+
+//#endregion
+//#region src/generated/client/api/postV1Routines.ts
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+function getPostV1RoutinesUrl() {
+	return {
+		method: "POST",
+		url: `/v1/routines`
+	};
+}
+/**
+* @summary Create a new routine
+* {@link /v1/routines}
+*/
+async function postV1Routines(headers, data, config = {}) {
+	const { client: request = fetch, ...requestConfig } = config;
+	const requestData = data;
+	return (await request({
+		method: "POST",
+		url: getPostV1RoutinesUrl().url.toString(),
+		data: requestData,
+		...requestConfig,
+		headers: {
+			...headers,
+			...requestConfig.headers
+		}
+	})).data;
+}
+
+//#endregion
+//#region src/generated/client/api/postV1Workouts.ts
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+function getPostV1WorkoutsUrl() {
+	return {
+		method: "POST",
+		url: `/v1/workouts`
+	};
+}
+/**
+* @summary Create a new workout
+* {@link /v1/workouts}
+*/
+async function postV1Workouts(headers, data, config = {}) {
+	const { client: request = fetch, ...requestConfig } = config;
+	const requestData = data;
+	return (await request({
+		method: "POST",
+		url: getPostV1WorkoutsUrl().url.toString(),
+		data: requestData,
+		...requestConfig,
+		headers: {
+			...headers,
+			...requestConfig.headers
+		}
+	})).data;
+}
+
+//#endregion
+//#region src/generated/client/api/putV1RoutinesRoutineid.ts
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+function getPutV1RoutinesRoutineidUrl(routineId) {
+	return {
+		method: "PUT",
+		url: `/v1/routines/${routineId}`
+	};
+}
+/**
+* @summary Update an existing routine
+* {@link /v1/routines/:routineId}
+*/
+async function putV1RoutinesRoutineid(routineId, headers, data, config = {}) {
+	const { client: request = fetch, ...requestConfig } = config;
+	const requestData = data;
+	return (await request({
+		method: "PUT",
+		url: getPutV1RoutinesRoutineidUrl(routineId).url.toString(),
+		data: requestData,
+		...requestConfig,
+		headers: {
+			...headers,
+			...requestConfig.headers
+		}
+	})).data;
+}
+
+//#endregion
+//#region src/generated/client/api/putV1WorkoutsWorkoutid.ts
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+function getPutV1WorkoutsWorkoutidUrl(workoutId) {
+	return {
+		method: "PUT",
+		url: `/v1/workouts/${workoutId}`
+	};
+}
+/**
+* @summary Update an existing workout
+* {@link /v1/workouts/:workoutId}
+*/
+async function putV1WorkoutsWorkoutid(workoutId, headers, data, config = {}) {
+	const { client: request = fetch, ...requestConfig } = config;
+	const requestData = data;
+	return (await request({
+		method: "PUT",
+		url: getPutV1WorkoutsWorkoutidUrl(workoutId).url.toString(),
+		data: requestData,
+		...requestConfig,
+		headers: {
+			...headers,
+			...requestConfig.headers
+		}
+	})).data;
+}
+
+//#endregion
+//#region src/utils/hevyClientKubb.ts
+function createClient$1(apiKey, baseUrl = "https://api.hevyapp.com") {
+	const axiosInstance = axios.create({
+		baseURL: baseUrl,
+		headers: { "api-key": apiKey }
+	});
+	const headers = { "api-key": apiKey };
+	const client = axiosInstance;
+	return {
+		getWorkouts: (params) => getV1Workouts(headers, params, { client }),
+		getWorkout: (workoutId) => getV1WorkoutsWorkoutid(workoutId, headers, { client }),
+		createWorkout: (data) => postV1Workouts(headers, data, { client }),
+		updateWorkout: (workoutId, data) => putV1WorkoutsWorkoutid(workoutId, headers, data, { client }),
+		getWorkoutCount: () => getV1WorkoutsCount(headers, { client }),
+		getWorkoutEvents: (params) => getV1WorkoutsEvents(headers, params, { client }),
+		getRoutines: (params) => getV1Routines(headers, params, { client }),
+		getRoutineById: (routineId) => getV1RoutinesRoutineid(routineId, headers, { client }),
+		createRoutine: (data) => postV1Routines(headers, data, { client }),
+		updateRoutine: (routineId, data) => putV1RoutinesRoutineid(routineId, headers, data, { client }),
+		getExerciseTemplates: (params) => getV1ExerciseTemplates(headers, params, { client }),
+		getExerciseTemplate: (templateId) => getV1ExerciseTemplatesExercisetemplateid(templateId, headers, { client }),
+		getExerciseHistory: (exerciseTemplateId, params) => getV1ExerciseHistoryExercisetemplateid(exerciseTemplateId, headers, params, { client }),
+		createExerciseTemplate: (data) => postV1ExerciseTemplates(headers, data, { client }),
+		getRoutineFolders: (params) => getV1RoutineFolders(headers, params, { client }),
+		createRoutineFolder: (data) => postV1RoutineFolders(headers, data, { client }),
+		getRoutineFolder: (folderId) => getV1RoutineFoldersFolderid(folderId, headers, { client }),
+		getWebhookSubscription: async () => {
+			throw new Error("Webhook subscription API not available. Please regenerate the client from the updated OpenAPI spec.");
+		},
+		createWebhookSubscription: async (_data) => {
+			throw new Error("Webhook subscription API not available. Please regenerate the client from the updated OpenAPI spec.");
+		},
+		deleteWebhookSubscription: async () => {
+			throw new Error("Webhook subscription API not available. Please regenerate the client from the updated OpenAPI spec.");
+		}
+	};
+}
+
+//#endregion
+//#region src/utils/hevyClient.ts
+function createClient(apiKey, baseUrl) {
+	return createClient$1(apiKey, baseUrl);
+}
+
+//#endregion
+//#region src/index.ts
+const name = "hevy-mcp";
+const version = "1.17.3";
+dotenvx.config({ quiet: true });
+const sentryConfig = {
+	dsn: "https://ce696d8333b507acbf5203eb877bce0f@o4508975499575296.ingest.de.sentry.io/4509049671647312",
+	release: process.env.SENTRY_RELEASE ?? `${name}@${version}`,
+	tracesSampleRate: 1,
+	sendDefaultPii: false
+};
+Sentry.init(sentryConfig);
+const HEVY_API_BASEURL = "https://api.hevyapp.com";
+const serverConfigSchema = z.object({ apiKey: z.string().min(1, "Hevy API key is required").describe("Your Hevy API key (available in the Hevy app settings).") });
+const configSchema = serverConfigSchema;
+function buildServer(apiKey) {
+	const baseServer = new McpServer({
+		name,
+		version
+	});
+	const server = Sentry.wrapMcpServerWithSentry(baseServer);
+	const hevyClient = createClient(apiKey, HEVY_API_BASEURL);
+	console.error("Hevy client initialized with API key");
+	registerWorkoutTools(server, hevyClient);
+	registerRoutineTools(server, hevyClient);
+	registerTemplateTools(server, hevyClient);
+	registerFolderTools(server, hevyClient);
+	registerWebhookTools(server, hevyClient);
+	return server;
+}
+function createServer({ config }) {
+	const { apiKey } = serverConfigSchema.parse(config);
+	return buildServer(apiKey).server;
+}
+async function runServer() {
+	const apiKey = parseConfig(process.argv.slice(2), process.env).apiKey;
+	assertApiKey(apiKey);
+	const server = buildServer(apiKey);
+	console.error("Starting MCP server in stdio mode");
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+}
+
+//#endregion
+export { createServer as n, runServer as r, configSchema as t };
+//# sourceMappingURL=src-BqxJlq7j.mjs.map