hevy-mcp 1.17.2 → 1.18.0

package/dist/cli.js

@@ -1,1458 +0,0 @@
-#!/usr/bin/env node
-// Generated with tsup
-// https://github.com/egoist/tsup
-
-// src/index.ts
-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 as z6 } from "zod";
-
-// src/tools/folders.ts
-import { z } from "zod";
-
-// src/utils/error-handler.ts
-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 contextPrefix = context ? `[${context}] ` : "";
-  const formattedMessage = `${contextPrefix}Error: ${errorMessage}`;
-  console.error(`${formattedMessage} (Type: ${errorType})`, error);
-  return {
-    content: [
-      {
-        type: "text",
-        text: formattedMessage
-      }
-    ],
-    isError: true
-  };
-}
-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 "NETWORK_ERROR" /* NETWORK_ERROR */;
-  }
-  if (nameLower.includes("validation") || messageLower.includes("validation") || messageLower.includes("invalid") || messageLower.includes("required")) {
-    return "VALIDATION_ERROR" /* VALIDATION_ERROR */;
-  }
-  if (messageLower.includes("not found") || messageLower.includes("404") || messageLower.includes("does not exist")) {
-    return "NOT_FOUND" /* NOT_FOUND */;
-  }
-  if (nameLower.includes("api") || messageLower.includes("api") || messageLower.includes("server error") || messageLower.includes("500")) {
-    return "API_ERROR" /* API_ERROR */;
-  }
-  return "UNKNOWN_ERROR" /* UNKNOWN_ERROR */;
-}
-function withErrorHandling(fn, context) {
-  return async (args) => {
-    try {
-      return await fn(args);
-    } catch (error) {
-      return createErrorResponse(error, context);
-    }
-  };
-}
-
-// src/utils/formatters.ts
-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
-        }))
-      };
-    })
-  };
-}
-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
-        }))
-      };
-    })
-  };
-}
-function formatRoutineFolder(folder) {
-  return {
-    id: folder.id,
-    title: folder.title,
-    createdAt: folder.created_at,
-    updatedAt: folder.updated_at
-  };
-}
-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)";
-    }
-    const hours = Math.floor(durationMs / (1e3 * 60 * 60));
-    const minutes = Math.floor(durationMs % (1e3 * 60 * 60) / (1e3 * 60));
-    const seconds = Math.floor(durationMs % (1e3 * 60) / 1e3);
-    return `${hours}h ${minutes}m ${seconds}s`;
-  } catch (error) {
-    console.error("Error calculating duration:", error);
-    return "Unknown duration";
-  }
-}
-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
-  };
-}
-
-// src/utils/response-formatter.ts
-function createJsonResponse(data, options = { pretty: true, indent: 2 }) {
-  const jsonString = options.pretty ? JSON.stringify(data, null, options.indent) : JSON.stringify(data);
-  return {
-    content: [
-      {
-        type: "text",
-        text: jsonString
-      }
-    ]
-  };
-}
-function createEmptyResponse(message = "No data found") {
-  return {
-    content: [
-      {
-        type: "text",
-        text: message
-      }
-    ]
-  };
-}
-
-// src/tools/folders.ts
-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 data = await hevyClient.getRoutineFolders({
-        page,
-        pageSize
-      });
-      const folders = data?.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`
-        );
-      }
-      const folder = formatRoutineFolder(data);
-      return createJsonResponse(folder);
-    }, "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: name2 } = args;
-      const data = await hevyClient.createRoutineFolder({
-        routine_folder: {
-          title: name2
-        }
-      });
-      if (!data) {
-        return createEmptyResponse(
-          "Failed to create routine folder: Server returned no data"
-        );
-      }
-      const folder = formatRoutineFolder(data);
-      return createJsonResponse(folder, {
-        pretty: true,
-        indent: 2
-      });
-    }, "create-routine-folder")
-  );
-}
-
-// src/tools/routines.ts
-import { z as z2 } from "zod";
-function registerRoutineTools(server, hevyClient) {
-  const getRoutinesSchema = {
-    page: z2.coerce.number().int().gte(1).default(1),
-    pageSize: z2.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 data = await hevyClient.getRoutines({
-        page,
-        pageSize
-      });
-      const routines = data?.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: z2.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`);
-      }
-      const routine = formatRoutine(data.routine);
-      return createJsonResponse(routine);
-    }, "get-routine")
-  );
-  const createRoutineSchema = {
-    title: z2.string().min(1),
-    folderId: z2.coerce.number().nullable().optional(),
-    notes: z2.string().optional(),
-    exercises: z2.array(
-      z2.object({
-        exerciseTemplateId: z2.string().min(1),
-        supersetId: z2.coerce.number().nullable().optional(),
-        restSeconds: z2.coerce.number().int().min(0).optional(),
-        notes: z2.string().optional(),
-        sets: z2.array(
-          z2.object({
-            type: z2.enum(["warmup", "normal", "failure", "dropset"]).default("normal"),
-            weight: z2.coerce.number().optional(),
-            weightKg: z2.coerce.number().optional(),
-            reps: z2.coerce.number().int().optional(),
-            distance: z2.coerce.number().int().optional(),
-            distanceMeters: z2.coerce.number().int().optional(),
-            duration: z2.coerce.number().int().optional(),
-            durationSeconds: z2.coerce.number().int().optional(),
-            customMetric: z2.coerce.number().optional(),
-            repRange: z2.object({
-              start: z2.coerce.number().int().optional(),
-              end: z2.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"
-        );
-      }
-      const routine = formatRoutine(data);
-      return createJsonResponse(routine, {
-        pretty: true,
-        indent: 2
-      });
-    }, "create-routine")
-  );
-  const updateRoutineSchema = {
-    routineId: z2.string().min(1),
-    title: z2.string().min(1),
-    notes: z2.string().optional(),
-    exercises: z2.array(
-      z2.object({
-        exerciseTemplateId: z2.string().min(1),
-        supersetId: z2.coerce.number().nullable().optional(),
-        restSeconds: z2.coerce.number().int().min(0).optional(),
-        notes: z2.string().optional(),
-        sets: z2.array(
-          z2.object({
-            type: z2.enum(["warmup", "normal", "failure", "dropset"]).default("normal"),
-            weight: z2.coerce.number().optional(),
-            weightKg: z2.coerce.number().optional(),
-            reps: z2.coerce.number().int().optional(),
-            distance: z2.coerce.number().int().optional(),
-            distanceMeters: z2.coerce.number().int().optional(),
-            duration: z2.coerce.number().int().optional(),
-            durationSeconds: z2.coerce.number().int().optional(),
-            customMetric: z2.coerce.number().optional(),
-            repRange: z2.object({
-              start: z2.coerce.number().int().optional(),
-              end: z2.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}`
-        );
-      }
-      const routine = formatRoutine(data);
-      return createJsonResponse(routine, {
-        pretty: true,
-        indent: 2
-      });
-    }, "update-routine")
-  );
-}
-
-// src/tools/templates.ts
-import { z as z3 } from "zod";
-function registerTemplateTools(server, hevyClient) {
-  const getExerciseTemplatesSchema = {
-    page: z3.coerce.number().int().gte(1).default(1),
-    pageSize: z3.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 data = await hevyClient.getExerciseTemplates({
-        page,
-        pageSize
-      });
-      const templates = data?.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: z3.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`
-        );
-      }
-      const template = formatExerciseTemplate(data);
-      return createJsonResponse(template);
-    }, "get-exercise-template")
-  );
-  const getExerciseHistorySchema = {
-    exerciseTemplateId: z3.string().min(1),
-    startDate: z3.string().datetime({ offset: true }).describe("ISO 8601 start date for filtering history").optional(),
-    endDate: z3.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 data = await hevyClient.getExerciseHistory(exerciseTemplateId, {
-        ...startDate ? { start_date: startDate } : {},
-        ...endDate ? { end_date: endDate } : {}
-      });
-      const history = data?.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: z3.string().min(1),
-    exerciseType: z3.enum([
-      "weight_reps",
-      "reps_only",
-      "bodyweight_reps",
-      "bodyweight_assisted_reps",
-      "duration",
-      "weight_duration",
-      "distance_duration",
-      "short_distance_weight"
-    ]),
-    equipmentCategory: z3.enum([
-      "none",
-      "barbell",
-      "dumbbell",
-      "kettlebell",
-      "machine",
-      "plate",
-      "resistance_band",
-      "suspension",
-      "other"
-    ]),
-    muscleGroup: z3.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: z3.array(
-      z3.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;
-      const response = await hevyClient.createExerciseTemplate({
-        exercise: {
-          title,
-          exercise_type: exerciseType,
-          equipment_category: equipmentCategory,
-          muscle_group: muscleGroup,
-          other_muscles: otherMuscles
-        }
-      });
-      return createJsonResponse({
-        id: response?.id,
-        message: "Exercise template created successfully"
-      });
-    }, "create-exercise-template")
-  );
-}
-
-// src/tools/webhooks.ts
-import { z as z4 } from "zod";
-var webhookUrlSchema = z4.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) {
-  const getWebhookSubscriptionSchema = {};
-  server.tool(
-    "get-webhook-subscription",
-    "Get the current webhook subscription for this account. Returns the webhook URL and auth token if a subscription exists.",
-    getWebhookSubscriptionSchema,
-    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: z4.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")
-  );
-  const deleteWebhookSubscriptionSchema = {};
-  server.tool(
-    "delete-webhook-subscription",
-    "Delete the current webhook subscription for this account. This will stop all webhook notifications.",
-    deleteWebhookSubscriptionSchema,
-    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")
-  );
-}
-
-// src/tools/workouts.ts
-import { z as z5 } from "zod";
-function registerWorkoutTools(server, hevyClient) {
-  const getWorkoutsSchema = {
-    page: z5.coerce.number().gte(1).default(1),
-    pageSize: z5.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 data = await hevyClient.getWorkouts({
-        page,
-        pageSize
-      });
-      const workouts = data?.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: z5.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`);
-      }
-      const workout = formatWorkout(data);
-      return createJsonResponse(workout);
-    }, "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();
-      const count = data ? data.workoutCount || 0 : 0;
-      return createJsonResponse({ count });
-    }, "get-workout-count")
-  );
-  const getWorkoutEventsSchema = {
-    page: z5.coerce.number().int().gte(1).default(1),
-    pageSize: z5.coerce.number().int().gte(1).lte(10).default(5),
-    since: z5.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 data = await hevyClient.getWorkoutEvents({
-        page,
-        pageSize,
-        since
-      });
-      const events = data?.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: z5.string().min(1),
-    description: z5.string().optional().nullable(),
-    startTime: z5.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
-    endTime: z5.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
-    routineId: z5.string().optional().nullable(),
-    isPrivate: z5.boolean().default(false),
-    exercises: z5.array(
-      z5.object({
-        exerciseTemplateId: z5.string().min(1),
-        supersetId: z5.coerce.number().nullable().optional(),
-        notes: z5.string().optional().nullable(),
-        sets: z5.array(
-          z5.object({
-            type: z5.enum(["warmup", "normal", "failure", "dropset"]).default("normal"),
-            weight: z5.coerce.number().optional().nullable(),
-            weightKg: z5.coerce.number().optional().nullable(),
-            reps: z5.coerce.number().int().optional().nullable(),
-            distance: z5.coerce.number().int().optional().nullable(),
-            distanceMeters: z5.coerce.number().int().optional().nullable(),
-            duration: z5.coerce.number().int().optional().nullable(),
-            durationSeconds: z5.coerce.number().int().optional().nullable(),
-            rpe: z5.coerce.number().optional().nullable(),
-            customMetric: z5.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 workoutPayload = {
-        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 requestBody = { workout: workoutPayload };
-      const data = await hevyClient.createWorkout(requestBody);
-      if (!data) {
-        return createEmptyResponse(
-          "Failed to create workout: Server returned no data"
-        );
-      }
-      const workout = formatWorkout(data);
-      return createJsonResponse(workout, {
-        pretty: true,
-        indent: 2
-      });
-    }, "create-workout")
-  );
-  const updateWorkoutSchema = {
-    workoutId: z5.string().min(1),
-    title: z5.string().min(1),
-    description: z5.string().optional().nullable(),
-    startTime: z5.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
-    endTime: z5.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
-    routineId: z5.string().optional().nullable(),
-    isPrivate: z5.boolean().default(false),
-    exercises: z5.array(
-      z5.object({
-        exerciseTemplateId: z5.string().min(1),
-        supersetId: z5.coerce.number().nullable().optional(),
-        notes: z5.string().optional().nullable(),
-        sets: z5.array(
-          z5.object({
-            type: z5.enum(["warmup", "normal", "failure", "dropset"]).default("normal"),
-            weight: z5.coerce.number().optional().nullable(),
-            weightKg: z5.coerce.number().optional().nullable(),
-            reps: z5.coerce.number().int().optional().nullable(),
-            distance: z5.coerce.number().int().optional().nullable(),
-            distanceMeters: z5.coerce.number().int().optional().nullable(),
-            duration: z5.coerce.number().int().optional().nullable(),
-            durationSeconds: z5.coerce.number().int().optional().nullable(),
-            rpe: z5.coerce.number().optional().nullable(),
-            customMetric: z5.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 workoutPayload = {
-        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 requestBody = { workout: workoutPayload };
-      const data = await hevyClient.updateWorkout(workoutId, requestBody);
-      if (!data) {
-        return createEmptyResponse(
-          `Failed to update workout with ID ${workoutId}`
-        );
-      }
-      const workout = formatWorkout(data);
-      return createJsonResponse(workout, {
-        pretty: true,
-        indent: 2
-      });
-    }, "update-workout-operation")
-  );
-}
-
-// src/utils/config.ts
-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);
-  }
-}
-
-// src/utils/hevyClientKubb.ts
-import axios from "axios";
-
-// src/generated/client/api/getV1ExerciseHistoryExercisetemplateid.ts
-import fetch from "@kubb/plugin-client/clients/axios";
-function getGetV1ExerciseHistoryExercisetemplateidUrl(exerciseTemplateId) {
-  const res = { method: "GET", url: `/v1/exercise_history/${exerciseTemplateId}` };
-  return res;
-}
-async function getV1ExerciseHistoryExercisetemplateid(exerciseTemplateId, headers, params, config = {}) {
-  const { client: request = fetch, ...requestConfig } = config;
-  const res = await request({ method: "GET", url: getGetV1ExerciseHistoryExercisetemplateidUrl(exerciseTemplateId).url.toString(), params, ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
-  return res.data;
-}
-
-// src/generated/client/api/getV1ExerciseTemplates.ts
-import fetch2 from "@kubb/plugin-client/clients/axios";
-function getGetV1ExerciseTemplatesUrl() {
-  const res = { method: "GET", url: `/v1/exercise_templates` };
-  return res;
-}
-async function getV1ExerciseTemplates(headers, params, config = {}) {
-  const { client: request = fetch2, ...requestConfig } = config;
-  const res = await request({ method: "GET", url: getGetV1ExerciseTemplatesUrl().url.toString(), params, ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
-  return res.data;
-}
-
-// src/generated/client/api/getV1ExerciseTemplatesExercisetemplateid.ts
-import fetch3 from "@kubb/plugin-client/clients/axios";
-function getGetV1ExerciseTemplatesExercisetemplateidUrl(exerciseTemplateId) {
-  const res = { method: "GET", url: `/v1/exercise_templates/${exerciseTemplateId}` };
-  return res;
-}
-async function getV1ExerciseTemplatesExercisetemplateid(exerciseTemplateId, headers, config = {}) {
-  const { client: request = fetch3, ...requestConfig } = config;
-  const res = await request({ method: "GET", url: getGetV1ExerciseTemplatesExercisetemplateidUrl(exerciseTemplateId).url.toString(), ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
-  return res.data;
-}
-
-// src/generated/client/api/getV1RoutineFolders.ts
-import fetch4 from "@kubb/plugin-client/clients/axios";
-function getGetV1RoutineFoldersUrl() {
-  const res = { method: "GET", url: `/v1/routine_folders` };
-  return res;
-}
-async function getV1RoutineFolders(headers, params, config = {}) {
-  const { client: request = fetch4, ...requestConfig } = config;
-  const res = await request({ method: "GET", url: getGetV1RoutineFoldersUrl().url.toString(), params, ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
-  return res.data;
-}
-
-// src/generated/client/api/getV1RoutineFoldersFolderid.ts
-import fetch5 from "@kubb/plugin-client/clients/axios";
-function getGetV1RoutineFoldersFolderidUrl(folderId) {
-  const res = { method: "GET", url: `/v1/routine_folders/${folderId}` };
-  return res;
-}
-async function getV1RoutineFoldersFolderid(folderId, headers, config = {}) {
-  const { client: request = fetch5, ...requestConfig } = config;
-  const res = await request({ method: "GET", url: getGetV1RoutineFoldersFolderidUrl(folderId).url.toString(), ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
-  return res.data;
-}
-
-// src/generated/client/api/getV1Routines.ts
-import fetch6 from "@kubb/plugin-client/clients/axios";
-function getGetV1RoutinesUrl() {
-  const res = { method: "GET", url: `/v1/routines` };
-  return res;
-}
-async function getV1Routines(headers, params, config = {}) {
-  const { client: request = fetch6, ...requestConfig } = config;
-  const res = await request({ method: "GET", url: getGetV1RoutinesUrl().url.toString(), params, ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
-  return res.data;
-}
-
-// src/generated/client/api/getV1RoutinesRoutineid.ts
-import fetch7 from "@kubb/plugin-client/clients/axios";
-function getGetV1RoutinesRoutineidUrl(routineId) {
-  const res = { method: "GET", url: `/v1/routines/${routineId}` };
-  return res;
-}
-async function getV1RoutinesRoutineid(routineId, headers, config = {}) {
-  const { client: request = fetch7, ...requestConfig } = config;
-  const res = await request({ method: "GET", url: getGetV1RoutinesRoutineidUrl(routineId).url.toString(), ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
-  return res.data;
-}
-
-// src/generated/client/api/getV1Workouts.ts
-import fetch8 from "@kubb/plugin-client/clients/axios";
-function getGetV1WorkoutsUrl() {
-  const res = { method: "GET", url: `/v1/workouts` };
-  return res;
-}
-async function getV1Workouts(headers, params, config = {}) {
-  const { client: request = fetch8, ...requestConfig } = config;
-  const res = await request({ method: "GET", url: getGetV1WorkoutsUrl().url.toString(), params, ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
-  return res.data;
-}
-
-// src/generated/client/api/getV1WorkoutsCount.ts
-import fetch9 from "@kubb/plugin-client/clients/axios";
-function getGetV1WorkoutsCountUrl() {
-  const res = { method: "GET", url: `/v1/workouts/count` };
-  return res;
-}
-async function getV1WorkoutsCount(headers, config = {}) {
-  const { client: request = fetch9, ...requestConfig } = config;
-  const res = await request({ method: "GET", url: getGetV1WorkoutsCountUrl().url.toString(), ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
-  return res.data;
-}
-
-// src/generated/client/api/getV1WorkoutsEvents.ts
-import fetch10 from "@kubb/plugin-client/clients/axios";
-function getGetV1WorkoutsEventsUrl() {
-  const res = { method: "GET", url: `/v1/workouts/events` };
-  return res;
-}
-async function getV1WorkoutsEvents(headers, params, config = {}) {
-  const { client: request = fetch10, ...requestConfig } = config;
-  const res = await request({ method: "GET", url: getGetV1WorkoutsEventsUrl().url.toString(), params, ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
-  return res.data;
-}
-
-// src/generated/client/api/getV1WorkoutsWorkoutid.ts
-import fetch11 from "@kubb/plugin-client/clients/axios";
-function getGetV1WorkoutsWorkoutidUrl(workoutId) {
-  const res = { method: "GET", url: `/v1/workouts/${workoutId}` };
-  return res;
-}
-async function getV1WorkoutsWorkoutid(workoutId, headers, config = {}) {
-  const { client: request = fetch11, ...requestConfig } = config;
-  const res = await request({ method: "GET", url: getGetV1WorkoutsWorkoutidUrl(workoutId).url.toString(), ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
-  return res.data;
-}
-
-// src/generated/client/api/postV1ExerciseTemplates.ts
-import fetch12 from "@kubb/plugin-client/clients/axios";
-function getPostV1ExerciseTemplatesUrl() {
-  const res = { method: "POST", url: `/v1/exercise_templates` };
-  return res;
-}
-async function postV1ExerciseTemplates(headers, data, config = {}) {
-  const { client: request = fetch12, ...requestConfig } = config;
-  const requestData = data;
-  const res = await request({ method: "POST", url: getPostV1ExerciseTemplatesUrl().url.toString(), data: requestData, ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
-  return res.data;
-}
-
-// src/generated/client/api/postV1RoutineFolders.ts
-import fetch13 from "@kubb/plugin-client/clients/axios";
-function getPostV1RoutineFoldersUrl() {
-  const res = { method: "POST", url: `/v1/routine_folders` };
-  return res;
-}
-async function postV1RoutineFolders(headers, data, config = {}) {
-  const { client: request = fetch13, ...requestConfig } = config;
-  const requestData = data;
-  const res = await request({ method: "POST", url: getPostV1RoutineFoldersUrl().url.toString(), data: requestData, ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
-  return res.data;
-}
-
-// src/generated/client/api/postV1Routines.ts
-import fetch14 from "@kubb/plugin-client/clients/axios";
-function getPostV1RoutinesUrl() {
-  const res = { method: "POST", url: `/v1/routines` };
-  return res;
-}
-async function postV1Routines(headers, data, config = {}) {
-  const { client: request = fetch14, ...requestConfig } = config;
-  const requestData = data;
-  const res = await request({ method: "POST", url: getPostV1RoutinesUrl().url.toString(), data: requestData, ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
-  return res.data;
-}
-
-// src/generated/client/api/postV1Workouts.ts
-import fetch15 from "@kubb/plugin-client/clients/axios";
-function getPostV1WorkoutsUrl() {
-  const res = { method: "POST", url: `/v1/workouts` };
-  return res;
-}
-async function postV1Workouts(headers, data, config = {}) {
-  const { client: request = fetch15, ...requestConfig } = config;
-  const requestData = data;
-  const res = await request({ method: "POST", url: getPostV1WorkoutsUrl().url.toString(), data: requestData, ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
-  return res.data;
-}
-
-// src/generated/client/api/putV1RoutinesRoutineid.ts
-import fetch16 from "@kubb/plugin-client/clients/axios";
-function getPutV1RoutinesRoutineidUrl(routineId) {
-  const res = { method: "PUT", url: `/v1/routines/${routineId}` };
-  return res;
-}
-async function putV1RoutinesRoutineid(routineId, headers, data, config = {}) {
-  const { client: request = fetch16, ...requestConfig } = config;
-  const requestData = data;
-  const res = await request({ method: "PUT", url: getPutV1RoutinesRoutineidUrl(routineId).url.toString(), data: requestData, ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
-  return res.data;
-}
-
-// src/generated/client/api/putV1WorkoutsWorkoutid.ts
-import fetch17 from "@kubb/plugin-client/clients/axios";
-function getPutV1WorkoutsWorkoutidUrl(workoutId) {
-  const res = { method: "PUT", url: `/v1/workouts/${workoutId}` };
-  return res;
-}
-async function putV1WorkoutsWorkoutid(workoutId, headers, data, config = {}) {
-  const { client: request = fetch17, ...requestConfig } = config;
-  const requestData = data;
-  const res = await request({ method: "PUT", url: getPutV1WorkoutsWorkoutidUrl(workoutId).url.toString(), data: requestData, ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
-  return res.data;
-}
-
-// src/utils/hevyClientKubb.ts
-function createClient(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 {
-    // Workouts
-    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 }),
-    // Routines
-    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
-    }),
-    // Exercise Templates
-    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 }),
-    // Routine Folders
-    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."
-      );
-    }
-  };
-}
-
-// src/utils/hevyClient.ts
-function createClient2(apiKey, baseUrl) {
-  return createClient(apiKey, baseUrl);
-}
-
-// src/index.ts
-var isBuiltArtifact = true ? true : false;
-if (isBuiltArtifact && false) {
-  throw new Error(
-    "Build-time variables __HEVY_MCP_NAME__ and __HEVY_MCP_VERSION__ must be defined."
-  );
-}
-var name = true ? "hevy-mcp" : "hevy-mcp";
-var version = true ? "1.17.1" : "dev";
-dotenvx.config({ quiet: true });
-var sentryRelease = process.env.SENTRY_RELEASE ?? `${name}@${version}`;
-var sentryConfig = {
-  dsn: "https://ce696d8333b507acbf5203eb877bce0f@o4508975499575296.ingest.de.sentry.io/4509049671647312",
-  release: sentryRelease,
-  // Tracing must be enabled for MCP monitoring to work
-  tracesSampleRate: 1,
-  sendDefaultPii: false
-};
-Sentry.init(sentryConfig);
-var HEVY_API_BASEURL = "https://api.hevyapp.com";
-var serverConfigSchema = z6.object({
-  apiKey: z6.string().min(1, "Hevy API key is required").describe("Your Hevy API key (available in the Hevy app settings).")
-});
-function buildServer(apiKey) {
-  const baseServer = new McpServer({
-    name,
-    version
-  });
-  const server = Sentry.wrapMcpServerWithSentry(baseServer);
-  const hevyClient = createClient2(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;
-}
-async function runServer() {
-  const args = process.argv.slice(2);
-  const cfg = parseConfig(args, process.env);
-  const apiKey = cfg.apiKey;
-  assertApiKey(apiKey);
-  const server = buildServer(apiKey);
-  console.error("Starting MCP server in stdio mode");
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
-
-// src/cli.ts
-void runServer().catch((error) => {
-  console.error("Fatal error in main():", error);
-  process.exit(1);
-});
-//# sourceMappingURL=cli.js.map