hevy-mcp 1.10.16 → 1.11.10

package/dist/index.js

@@ -9,7 +9,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 
 // package.json
 var name = "hevy-mcp";
-var version = "1.10.15";
+var version = "1.11.9";
 
 // src/tools/folders.ts
 import { z } from "zod";
@@ -198,6 +198,11 @@ function registerFolderTools(server2, hevyClient2) {
     },
     withErrorHandling(
       async ({ page, pageSize }) => {
+        if (!hevyClient2) {
+          throw new Error(
+            "API client not initialized. Please provide HEVY_API_KEY."
+          );
+        }
         const data = await hevyClient2.getRoutineFolders({
           page,
           pageSize
@@ -222,6 +227,11 @@ function registerFolderTools(server2, hevyClient2) {
       folderId: z.string().min(1)
     },
     withErrorHandling(async ({ folderId }) => {
+      if (!hevyClient2) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
       const data = await hevyClient2.getRoutineFolder(folderId);
       if (!data) {
         return createEmptyResponse(
@@ -239,6 +249,11 @@ function registerFolderTools(server2, hevyClient2) {
       name: z.string().min(1)
     },
     withErrorHandling(async ({ name: name2 }) => {
+      if (!hevyClient2) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
       const data = await hevyClient2.createRoutineFolder({
         routine_folder: {
           title: name2
@@ -269,6 +284,11 @@ function registerRoutineTools(server2, hevyClient2) {
       pageSize: z2.coerce.number().int().gte(1).lte(10).default(5)
     },
     withErrorHandling(async (args2) => {
+      if (!hevyClient2) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
       const { page, pageSize } = args2;
       const data = await hevyClient2.getRoutines({
         page,
@@ -290,6 +310,11 @@ function registerRoutineTools(server2, hevyClient2) {
       routineId: z2.string().min(1)
     },
     withErrorHandling(async ({ routineId }) => {
+      if (!hevyClient2) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
       const data = await hevyClient2.getRoutineById(String(routineId));
       if (!data || !data.routine) {
         return createEmptyResponse(`Routine with ID ${routineId} not found`);
@@ -325,6 +350,11 @@ function registerRoutineTools(server2, hevyClient2) {
       )
     },
     withErrorHandling(async (args2) => {
+      if (!hevyClient2) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
       const { title, folderId, notes, exercises } = args2;
       const data = await hevyClient2.createRoutine({
         routine: {
@@ -390,6 +420,11 @@ function registerRoutineTools(server2, hevyClient2) {
       )
     },
     withErrorHandling(async (args2) => {
+      if (!hevyClient2) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
       const { routineId, title, notes, exercises } = args2;
       const data = await hevyClient2.updateRoutine(routineId, {
         routine: {
@@ -441,6 +476,11 @@ function registerTemplateTools(server2, hevyClient2) {
     },
     withErrorHandling(
       async ({ page, pageSize }) => {
+        if (!hevyClient2) {
+          throw new Error(
+            "API client not initialized. Please provide HEVY_API_KEY."
+          );
+        }
         const data = await hevyClient2.getExerciseTemplates({
           page,
           pageSize
@@ -466,6 +506,11 @@ function registerTemplateTools(server2, hevyClient2) {
     },
     withErrorHandling(
       async ({ exerciseTemplateId }) => {
+        if (!hevyClient2) {
+          throw new Error(
+            "API client not initialized. Please provide HEVY_API_KEY."
+          );
+        }
         const data = await hevyClient2.getExerciseTemplate(exerciseTemplateId);
         if (!data) {
           return createEmptyResponse(
@@ -486,9 +531,9 @@ import { z as z40 } from "zod";
 // src/generated/client/schemas/deletedWorkoutSchema.ts
 import { z as z4 } from "zod";
 var deletedWorkoutSchema = z4.object({
-  type: z4.string().describe("Indicates the type of the event (deleted)"),
-  id: z4.string().describe("The unique identifier of the deleted workout"),
-  deleted_at: z4.string().describe("A date string indicating when the workout was deleted").optional()
+  "type": z4.string().describe("Indicates the type of the event (deleted)"),
+  "id": z4.string().describe("The unique identifier of the deleted workout"),
+  "deleted_at": z4.optional(z4.string().describe("A date string indicating when the workout was deleted"))
 });
 
 // src/generated/client/schemas/deleteV1WebhookSubscriptionSchema.ts
@@ -497,155 +542,142 @@ var deleteV1WebhookSubscriptionHeaderParamsSchema = z5.object({
   "api-key": z5.string().uuid().describe("Your API key")
 });
 var deleteV1WebhookSubscription200Schema = z5.any();
-var deleteV1WebhookSubscriptionMutationResponseSchema = z5.lazy(() => deleteV1WebhookSubscription200Schema);
 
 // src/generated/client/schemas/exerciseTemplateSchema.ts
 import { z as z6 } from "zod";
 var exerciseTemplateSchema = z6.object({
-  id: z6.string().describe("The exercise template ID.").optional(),
-  title: z6.string().describe("The exercise title.").optional(),
-  type: z6.string().describe("The exercise type.").optional(),
-  primary_muscle_group: z6.string().describe("The primary muscle group of the exercise.").optional(),
-  secondary_muscle_groups: z6.array(z6.string()).describe("The secondary muscle groups of the exercise.").optional(),
-  is_custom: z6.boolean().describe("A boolean indicating whether the exercise is a custom exercise.").optional()
+  "id": z6.optional(z6.string().describe("The exercise template ID.")),
+  "title": z6.optional(z6.string().describe("The exercise title.")),
+  "type": z6.optional(z6.string().describe("The exercise type.")),
+  "primary_muscle_group": z6.optional(z6.string().describe("The primary muscle group of the exercise.")),
+  "secondary_muscle_groups": z6.optional(z6.array(z6.string()).describe("The secondary muscle groups of the exercise.")),
+  "is_custom": z6.optional(z6.boolean().describe("A boolean indicating whether the exercise is a custom exercise."))
 });
 
 // src/generated/client/schemas/getV1ExerciseTemplatesExercisetemplateidSchema.ts
 import { z as z7 } from "zod";
 var getV1ExerciseTemplatesExercisetemplateidPathParamsSchema = z7.object({
-  exerciseTemplateId: z7.any()
+  "exerciseTemplateId": z7.any()
 });
 var getV1ExerciseTemplatesExercisetemplateidHeaderParamsSchema = z7.object({
   "api-key": z7.string().uuid()
 });
-var getV1ExerciseTemplatesExercisetemplateid200Schema = z7.lazy(() => exerciseTemplateSchema);
 var getV1ExerciseTemplatesExercisetemplateid404Schema = z7.any();
-var getV1ExerciseTemplatesExercisetemplateidQueryResponseSchema = z7.lazy(() => getV1ExerciseTemplatesExercisetemplateid200Schema);
 
 // src/generated/client/schemas/getV1ExerciseTemplatesSchema.ts
 import { z as z8 } from "zod";
 var getV1ExerciseTemplatesQueryParamsSchema = z8.object({
-  page: z8.coerce.number().int().default(1).describe("Page number (Must be 1 or greater)"),
-  pageSize: z8.coerce.number().int().default(5).describe("Number of items on the requested page (Max 100)")
+  "page": z8.coerce.number().int().default(1).describe("Page number (Must be 1 or greater)"),
+  "pageSize": z8.coerce.number().int().default(5).describe("Number of items on the requested page (Max 100)")
 });
 var getV1ExerciseTemplatesHeaderParamsSchema = z8.object({
   "api-key": z8.string().uuid()
 });
 var getV1ExerciseTemplates200Schema = z8.object({
-  page: z8.number().int().default(1).describe("Current page number"),
-  page_count: z8.number().int().default(5).describe("Total number of pages"),
-  exercise_templates: z8.array(z8.lazy(() => exerciseTemplateSchema)).optional()
+  "page": z8.optional(z8.number().int().default(1).describe("Current page number")),
+  "page_count": z8.optional(z8.number().int().default(5).describe("Total number of pages")),
+  "exercise_templates": z8.optional(z8.array(z8.lazy(() => exerciseTemplateSchema)))
 });
 var getV1ExerciseTemplates400Schema = z8.any();
-var getV1ExerciseTemplatesQueryResponseSchema = z8.lazy(() => getV1ExerciseTemplates200Schema);
 
 // src/generated/client/schemas/routineFolderSchema.ts
 import { z as z9 } from "zod";
 var routineFolderSchema = z9.object({
-  id: z9.number().describe("The routine folder ID.").optional(),
-  index: z9.number().describe("The routine folder index. Describes the order of the folder in the list.").optional(),
-  title: z9.string().describe("The routine folder title.").optional(),
-  updated_at: z9.string().describe("ISO 8601 timestamp of when the folder was last updated.").optional(),
-  created_at: z9.string().describe("ISO 8601 timestamp of when the folder was created.").optional()
+  "id": z9.optional(z9.number().describe("The routine folder ID.")),
+  "index": z9.optional(z9.number().describe("The routine folder index. Describes the order of the folder in the list.")),
+  "title": z9.optional(z9.string().describe("The routine folder title.")),
+  "updated_at": z9.optional(z9.string().describe("ISO 8601 timestamp of when the folder was last updated.")),
+  "created_at": z9.optional(z9.string().describe("ISO 8601 timestamp of when the folder was created."))
 });
 
 // src/generated/client/schemas/getV1RoutineFoldersFolderidSchema.ts
 import { z as z10 } from "zod";
 var getV1RoutineFoldersFolderidPathParamsSchema = z10.object({
-  folderId: z10.any()
+  "folderId": z10.any()
 });
 var getV1RoutineFoldersFolderidHeaderParamsSchema = z10.object({
   "api-key": z10.string().uuid()
 });
-var getV1RoutineFoldersFolderid200Schema = z10.lazy(() => routineFolderSchema);
 var getV1RoutineFoldersFolderid404Schema = z10.any();
-var getV1RoutineFoldersFolderidQueryResponseSchema = z10.lazy(() => getV1RoutineFoldersFolderid200Schema);
 
 // src/generated/client/schemas/getV1RoutineFoldersSchema.ts
 import { z as z11 } from "zod";
 var getV1RoutineFoldersQueryParamsSchema = z11.object({
-  page: z11.coerce.number().int().default(1).describe("Page number (Must be 1 or greater)"),
-  pageSize: z11.coerce.number().int().default(5).describe("Number of items on the requested page (Max 10)")
+  "page": z11.coerce.number().int().default(1).describe("Page number (Must be 1 or greater)"),
+  "pageSize": z11.coerce.number().int().default(5).describe("Number of items on the requested page (Max 10)")
 });
 var getV1RoutineFoldersHeaderParamsSchema = z11.object({
   "api-key": z11.string().uuid()
 });
 var getV1RoutineFolders200Schema = z11.object({
-  page: z11.number().int().default(1).describe("Current page number"),
-  page_count: z11.number().int().default(5).describe("Total number of pages"),
-  routine_folders: z11.array(z11.lazy(() => routineFolderSchema)).optional()
+  "page": z11.optional(z11.number().int().default(1).describe("Current page number")),
+  "page_count": z11.optional(z11.number().int().default(5).describe("Total number of pages")),
+  "routine_folders": z11.optional(z11.array(z11.lazy(() => routineFolderSchema)))
 });
 var getV1RoutineFolders400Schema = z11.any();
-var getV1RoutineFoldersQueryResponseSchema = z11.lazy(() => getV1RoutineFolders200Schema);
 
 // src/generated/client/schemas/routineSchema.ts
 import { z as z12 } from "zod";
 var routineSchema = z12.object({
-  id: z12.string().describe("The routine ID.").optional(),
-  title: z12.string().describe("The routine title.").optional(),
-  folder_id: z12.number().describe("The routine folder ID.").nullable().nullish(),
-  updated_at: z12.string().describe("ISO 8601 timestamp of when the routine was last updated.").optional(),
-  created_at: z12.string().describe("ISO 8601 timestamp of when the routine was created.").optional(),
-  exercises: z12.array(
-    z12.object({
-      index: z12.number().describe("Index indicating the order of the exercise in the routine.").optional(),
-      title: z12.string().describe("Title of the exercise").optional(),
-      rest_seconds: z12.string().describe("The rest time in seconds between sets of the exercise").optional(),
-      notes: z12.string().describe("Routine notes on the exercise").optional(),
-      exercise_template_id: z12.string().describe("The id of the exercise template. This can be used to fetch the exercise template.").optional(),
-      supersets_id: z12.number().describe("The id of the superset that the exercise belongs to. A value of null indicates the exercise is not part of a superset.").nullable().nullish(),
-      sets: z12.array(
-        z12.object({
-          index: z12.number().describe("Index indicating the order of the set in the routine.").optional(),
-          type: z12.string().describe("The type of set. This can be one of 'normal', 'warmup', 'dropset', 'failure'").optional(),
-          weight_kg: z12.number().describe("Weight lifted in kilograms.").nullable().nullish(),
-          reps: z12.number().describe("Number of reps logged for the set").nullable().nullish(),
-          rep_range: z12.object({
-            start: z12.number().describe("Starting rep count for the range").nullable().nullish(),
-            end: z12.number().describe("Ending rep count for the range").nullable().nullish()
-          }).describe("Range of reps for the set, if applicable").nullable().nullish(),
-          distance_meters: z12.number().describe("Number of meters logged for the set").nullable().nullish(),
-          duration_seconds: z12.number().describe("Number of seconds logged for the set").nullable().nullish(),
-          rpe: z12.number().describe("RPE (Relative perceived exertion) value logged for the set").nullable().nullish(),
-          custom_metric: z12.number().describe("Custom metric logged for the set (Currently only used to log floors or steps for stair machine exercises)").nullable().nullish()
-        })
-      ).optional()
-    })
-  ).optional()
+  "id": z12.optional(z12.string().describe("The routine ID.")),
+  "title": z12.optional(z12.string().describe("The routine title.")),
+  "folder_id": z12.number().describe("The routine folder ID.").nullish(),
+  "updated_at": z12.optional(z12.string().describe("ISO 8601 timestamp of when the routine was last updated.")),
+  "created_at": z12.optional(z12.string().describe("ISO 8601 timestamp of when the routine was created.")),
+  "exercises": z12.optional(z12.array(z12.object({
+    "index": z12.optional(z12.number().describe("Index indicating the order of the exercise in the routine.")),
+    "title": z12.optional(z12.string().describe("Title of the exercise")),
+    "rest_seconds": z12.optional(z12.string().describe("The rest time in seconds between sets of the exercise")),
+    "notes": z12.optional(z12.string().describe("Routine notes on the exercise")),
+    "exercise_template_id": z12.optional(z12.string().describe("The id of the exercise template. This can be used to fetch the exercise template.")),
+    "supersets_id": z12.number().describe("The id of the superset that the exercise belongs to. A value of null indicates the exercise is not part of a superset.").nullish(),
+    "sets": z12.optional(z12.array(z12.object({
+      "index": z12.optional(z12.number().describe("Index indicating the order of the set in the routine.")),
+      "type": z12.optional(z12.string().describe("The type of set. This can be one of 'normal', 'warmup', 'dropset', 'failure'")),
+      "weight_kg": z12.number().describe("Weight lifted in kilograms.").nullish(),
+      "reps": z12.number().describe("Number of reps logged for the set").nullish(),
+      "rep_range": z12.object({
+        "start": z12.number().describe("Starting rep count for the range").nullish(),
+        "end": z12.number().describe("Ending rep count for the range").nullish()
+      }).describe("Range of reps for the set, if applicable").nullish(),
+      "distance_meters": z12.number().describe("Number of meters logged for the set").nullish(),
+      "duration_seconds": z12.number().describe("Number of seconds logged for the set").nullish(),
+      "rpe": z12.number().describe("RPE (Relative perceived exertion) value logged for the set").nullish(),
+      "custom_metric": z12.number().describe("Custom metric logged for the set (Currently only used to log floors or steps for stair machine exercises)").nullish()
+    })))
+  })))
 });
 
 // src/generated/client/schemas/getV1RoutinesRoutineidSchema.ts
 import { z as z13 } from "zod";
 var getV1RoutinesRoutineidPathParamsSchema = z13.object({
-  routineId: z13.any()
+  "routineId": z13.any()
 });
 var getV1RoutinesRoutineidHeaderParamsSchema = z13.object({
   "api-key": z13.string().uuid()
 });
 var getV1RoutinesRoutineid200Schema = z13.object({
-  routine: z13.lazy(() => routineSchema).optional()
+  "routine": z13.optional(z13.lazy(() => routineSchema))
 });
 var getV1RoutinesRoutineid400Schema = z13.object({
-  error: z13.string().describe("Error message").optional()
+  "error": z13.optional(z13.string().describe("Error message"))
 });
-var getV1RoutinesRoutineidQueryResponseSchema = z13.lazy(() => getV1RoutinesRoutineid200Schema);
 
 // src/generated/client/schemas/getV1RoutinesSchema.ts
 import { z as z14 } from "zod";
 var getV1RoutinesQueryParamsSchema = z14.object({
-  page: z14.coerce.number().int().default(1).describe("Page number (Must be 1 or greater)"),
-  pageSize: z14.coerce.number().int().default(5).describe("Number of items on the requested page (Max 10)")
+  "page": z14.coerce.number().int().default(1).describe("Page number (Must be 1 or greater)"),
+  "pageSize": z14.coerce.number().int().default(5).describe("Number of items on the requested page (Max 10)")
 });
 var getV1RoutinesHeaderParamsSchema = z14.object({
   "api-key": z14.string().uuid()
 });
 var getV1Routines200Schema = z14.object({
-  page: z14.number().int().describe("Current page number").optional(),
-  page_count: z14.number().int().describe("Total number of pages").optional(),
-  routines: z14.array(z14.lazy(() => routineSchema)).optional()
+  "page": z14.optional(z14.number().int().describe("Current page number")),
+  "page_count": z14.optional(z14.number().int().describe("Total number of pages")),
+  "routines": z14.optional(z14.array(z14.lazy(() => routineSchema)))
 });
 var getV1Routines400Schema = z14.any();
-var getV1RoutinesQueryResponseSchema = z14.lazy(() => getV1Routines200Schema);
 
 // src/generated/client/schemas/getV1WebhookSubscriptionSchema.ts
 import { z as z15 } from "zod";
@@ -653,11 +685,10 @@ var getV1WebhookSubscriptionHeaderParamsSchema = z15.object({
   "api-key": z15.string().uuid().describe("Your API key")
 });
 var getV1WebhookSubscription200Schema = z15.object({
-  url: z15.string().describe("The webhook URL").optional(),
-  auth_token: z15.string().describe("The auth token for the webhook").optional()
+  "url": z15.optional(z15.string().describe("The webhook URL")),
+  "auth_token": z15.optional(z15.string().describe("The auth token for the webhook"))
 });
 var getV1WebhookSubscription404Schema = z15.any();
-var getV1WebhookSubscriptionQueryResponseSchema = z15.lazy(() => getV1WebhookSubscription200Schema);
 
 // src/generated/client/schemas/getV1WorkoutsCountSchema.ts
 import { z as z16 } from "zod";
@@ -665,143 +696,133 @@ var getV1WorkoutsCountHeaderParamsSchema = z16.object({
   "api-key": z16.string().uuid()
 });
 var getV1WorkoutsCount200Schema = z16.object({
-  workout_count: z16.number().int().default(42).describe("The total number of workouts")
+  "workout_count": z16.optional(z16.number().int().default(42).describe("The total number of workouts"))
 });
-var getV1WorkoutsCountQueryResponseSchema = z16.lazy(() => getV1WorkoutsCount200Schema);
 
 // src/generated/client/schemas/workoutSchema.ts
 import { z as z17 } from "zod";
 var workoutSchema = z17.object({
-  id: z17.string().describe("The workout ID.").optional(),
-  title: z17.string().describe("The workout title.").optional(),
-  description: z17.string().describe("The workout description.").optional(),
-  start_time: z17.number().describe("ISO 8601 timestamp of when the workout was recorded to have started.").optional(),
-  end_time: z17.number().describe("ISO 8601 timestamp of when the workout was recorded to have ended.").optional(),
-  updated_at: z17.string().describe("ISO 8601 timestamp of when the workout was last updated.").optional(),
-  created_at: z17.string().describe("ISO 8601 timestamp of when the workout was created.").optional(),
-  exercises: z17.array(
-    z17.object({
-      index: z17.number().describe("Index indicating the order of the exercise in the workout.").optional(),
-      title: z17.string().describe("Title of the exercise").optional(),
-      notes: z17.string().describe("Notes on the exercise").optional(),
-      exercise_template_id: z17.string().describe("The id of the exercise template. This can be used to fetch the exercise template.").optional(),
-      supersets_id: z17.number().describe("The id of the superset that the exercise belongs to. A value of null indicates the exercise is not part of a superset.").nullable().nullish(),
-      sets: z17.array(
-        z17.object({
-          index: z17.number().describe("Index indicating the order of the set in the workout.").optional(),
-          type: z17.string().describe("The type of set. This can be one of 'normal', 'warmup', 'dropset', 'failure'").optional(),
-          weight_kg: z17.number().describe("Weight lifted in kilograms.").nullable().nullish(),
-          reps: z17.number().describe("Number of reps logged for the set").nullable().nullish(),
-          distance_meters: z17.number().describe("Number of meters logged for the set").nullable().nullish(),
-          duration_seconds: z17.number().describe("Number of seconds logged for the set").nullable().nullish(),
-          rpe: z17.number().describe("RPE (Relative perceived exertion) value logged for the set").nullable().nullish(),
-          custom_metric: z17.number().describe("Custom metric logged for the set (Currently only used to log floors or steps for stair machine exercises)").nullable().nullish()
-        })
-      ).optional()
-    })
-  ).optional()
+  "id": z17.optional(z17.string().describe("The workout ID.")),
+  "title": z17.optional(z17.string().describe("The workout title.")),
+  "description": z17.optional(z17.string().describe("The workout description.")),
+  "start_time": z17.optional(z17.number().describe("ISO 8601 timestamp of when the workout was recorded to have started.")),
+  "end_time": z17.optional(z17.number().describe("ISO 8601 timestamp of when the workout was recorded to have ended.")),
+  "updated_at": z17.optional(z17.string().describe("ISO 8601 timestamp of when the workout was last updated.")),
+  "created_at": z17.optional(z17.string().describe("ISO 8601 timestamp of when the workout was created.")),
+  "exercises": z17.optional(z17.array(z17.object({
+    "index": z17.optional(z17.number().describe("Index indicating the order of the exercise in the workout.")),
+    "title": z17.optional(z17.string().describe("Title of the exercise")),
+    "notes": z17.optional(z17.string().describe("Notes on the exercise")),
+    "exercise_template_id": z17.optional(z17.string().describe("The id of the exercise template. This can be used to fetch the exercise template.")),
+    "supersets_id": z17.number().describe("The id of the superset that the exercise belongs to. A value of null indicates the exercise is not part of a superset.").nullish(),
+    "sets": z17.optional(z17.array(z17.object({
+      "index": z17.optional(z17.number().describe("Index indicating the order of the set in the workout.")),
+      "type": z17.optional(z17.string().describe("The type of set. This can be one of 'normal', 'warmup', 'dropset', 'failure'")),
+      "weight_kg": z17.number().describe("Weight lifted in kilograms.").nullish(),
+      "reps": z17.number().describe("Number of reps logged for the set").nullish(),
+      "distance_meters": z17.number().describe("Number of meters logged for the set").nullish(),
+      "duration_seconds": z17.number().describe("Number of seconds logged for the set").nullish(),
+      "rpe": z17.number().describe("RPE (Relative perceived exertion) value logged for the set").nullish(),
+      "custom_metric": z17.number().describe("Custom metric logged for the set (Currently only used to log floors or steps for stair machine exercises)").nullish()
+    })))
+  })))
 });
 
 // src/generated/client/schemas/updatedWorkoutSchema.ts
 import { z as z18 } from "zod";
 var updatedWorkoutSchema = z18.object({
-  type: z18.string().describe("Indicates the type of the event (updated)"),
-  workout: z18.lazy(() => workoutSchema)
+  "type": z18.string().describe("Indicates the type of the event (updated)"),
+  "workout": z18.lazy(() => workoutSchema)
 });
 
 // src/generated/client/schemas/paginatedWorkoutEventsSchema.ts
 import { z as z19 } from "zod";
 var paginatedWorkoutEventsSchema = z19.object({
-  page: z19.number().int().describe("The current page number"),
-  page_count: z19.number().int().describe("The total number of pages available"),
-  events: z19.array(z19.union([z19.lazy(() => updatedWorkoutSchema), z19.lazy(() => deletedWorkoutSchema)])).describe("An array of workout events (either updated or deleted)")
+  "page": z19.number().int().describe("The current page number"),
+  "page_count": z19.number().int().describe("The total number of pages available"),
+  "events": z19.array(z19.union([z19.lazy(() => updatedWorkoutSchema), z19.lazy(() => deletedWorkoutSchema)])).describe("An array of workout events (either updated or deleted)")
 });
 
 // src/generated/client/schemas/getV1WorkoutsEventsSchema.ts
 import { z as z20 } from "zod";
 var getV1WorkoutsEventsQueryParamsSchema = z20.object({
-  page: z20.coerce.number().int().default(1).describe("Page number (Must be 1 or greater)"),
-  pageSize: z20.coerce.number().int().default(5).describe("Number of items on the requested page (Max 10)"),
-  since: z20.string().default("1970-01-01T00:00:00Z")
+  "page": z20.coerce.number().int().default(1).describe("Page number (Must be 1 or greater)"),
+  "pageSize": z20.coerce.number().int().default(5).describe("Number of items on the requested page (Max 10)"),
+  "since": z20.string().default("1970-01-01T00:00:00Z")
 });
 var getV1WorkoutsEventsHeaderParamsSchema = z20.object({
   "api-key": z20.string().uuid()
 });
-var getV1WorkoutsEvents200Schema = z20.lazy(() => paginatedWorkoutEventsSchema);
 var getV1WorkoutsEvents500Schema = z20.any();
-var getV1WorkoutsEventsQueryResponseSchema = z20.lazy(() => getV1WorkoutsEvents200Schema);
 
 // src/generated/client/schemas/getV1WorkoutsSchema.ts
 import { z as z21 } from "zod";
 var getV1WorkoutsQueryParamsSchema = z21.object({
-  page: z21.coerce.number().int().default(1).describe("Page number (Must be 1 or greater)"),
-  pageSize: z21.coerce.number().int().default(5).describe("Number of items on the requested page (Max 10)")
+  "page": z21.coerce.number().int().default(1).describe("Page number (Must be 1 or greater)"),
+  "pageSize": z21.coerce.number().int().default(5).describe("Number of items on the requested page (Max 10)")
 });
 var getV1WorkoutsHeaderParamsSchema = z21.object({
   "api-key": z21.string().uuid()
 });
 var getV1Workouts200Schema = z21.object({
-  page: z21.number().int().describe("Current page number").optional(),
-  page_count: z21.number().int().describe("Total number of pages").optional(),
-  workouts: z21.array(z21.lazy(() => workoutSchema)).optional()
+  "page": z21.optional(z21.number().int().describe("Current page number")),
+  "page_count": z21.optional(z21.number().int().describe("Total number of pages")),
+  "workouts": z21.optional(z21.array(z21.lazy(() => workoutSchema)))
 });
 var getV1Workouts400Schema = z21.any();
-var getV1WorkoutsQueryResponseSchema = z21.lazy(() => getV1Workouts200Schema);
 
 // src/generated/client/schemas/getV1WorkoutsWorkoutidSchema.ts
 import { z as z22 } from "zod";
 var getV1WorkoutsWorkoutidPathParamsSchema = z22.object({
-  workoutId: z22.any()
+  "workoutId": z22.any()
 });
 var getV1WorkoutsWorkoutidHeaderParamsSchema = z22.object({
   "api-key": z22.string().uuid()
 });
-var getV1WorkoutsWorkoutid200Schema = z22.lazy(() => workoutSchema);
 var getV1WorkoutsWorkoutid404Schema = z22.any();
-var getV1WorkoutsWorkoutidQueryResponseSchema = z22.lazy(() => getV1WorkoutsWorkoutid200Schema);
 
 // src/generated/client/schemas/postRoutineFolderRequestBodySchema.ts
 import { z as z23 } from "zod";
 var postRoutineFolderRequestBodySchema = z23.object({
-  routine_folder: z23.object({
-    title: z23.string().describe("The title of the routine folder.").optional()
-  }).optional()
+  "routine_folder": z23.optional(z23.object({
+    "title": z23.optional(z23.string().describe("The title of the routine folder."))
+  }))
 });
 
 // src/generated/client/schemas/postRoutinesRequestSetSchema.ts
 import { z as z24 } from "zod";
 var postRoutinesRequestSetSchema = z24.object({
-  type: z24.enum(["warmup", "normal", "failure", "dropset"]).describe("The type of the set.").optional(),
-  weight_kg: z24.number().describe("The weight in kilograms.").nullable().nullish(),
-  reps: z24.number().int().describe("The number of repetitions.").nullable().nullish(),
-  distance_meters: z24.number().int().describe("The distance in meters.").nullable().nullish(),
-  duration_seconds: z24.number().int().describe("The duration in seconds.").nullable().nullish(),
-  custom_metric: z24.number().describe("A custom metric for the set. Currently used for steps and floors.").nullable().nullish(),
-  rep_range: z24.object({
-    start: z24.number().describe("Starting rep count for the range").nullable().nullish(),
-    end: z24.number().describe("Ending rep count for the range").nullable().nullish()
-  }).describe("Range of reps for the set, if applicable").nullable().nullish()
+  "type": z24.optional(z24.enum(["warmup", "normal", "failure", "dropset"]).describe("The type of the set.")),
+  "weight_kg": z24.number().describe("The weight in kilograms.").nullish(),
+  "reps": z24.number().int().describe("The number of repetitions.").nullish(),
+  "distance_meters": z24.number().int().describe("The distance in meters.").nullish(),
+  "duration_seconds": z24.number().int().describe("The duration in seconds.").nullish(),
+  "custom_metric": z24.number().describe("A custom metric for the set. Currently used for steps and floors.").nullish(),
+  "rep_range": z24.object({
+    "start": z24.number().describe("Starting rep count for the range").nullish(),
+    "end": z24.number().describe("Ending rep count for the range").nullish()
+  }).describe("Range of reps for the set, if applicable").nullish()
 });
 
 // src/generated/client/schemas/postRoutinesRequestExerciseSchema.ts
 import { z as z25 } from "zod";
 var postRoutinesRequestExerciseSchema = z25.object({
-  exercise_template_id: z25.string().describe("The ID of the exercise template.").optional(),
-  superset_id: z25.number().int().describe("The ID of the superset.").nullable().nullish(),
-  rest_seconds: z25.number().int().describe("The rest time in seconds.").nullable().nullish(),
-  notes: z25.string().describe("Additional notes for the exercise.").nullable().nullish(),
-  sets: z25.array(z25.lazy(() => postRoutinesRequestSetSchema)).optional()
+  "exercise_template_id": z25.optional(z25.string().describe("The ID of the exercise template.")),
+  "superset_id": z25.number().int().describe("The ID of the superset.").nullish(),
+  "rest_seconds": z25.number().int().describe("The rest time in seconds.").nullish(),
+  "notes": z25.string().describe("Additional notes for the exercise.").nullish(),
+  "sets": z25.optional(z25.array(z25.lazy(() => postRoutinesRequestSetSchema)))
 });
 
 // src/generated/client/schemas/postRoutinesRequestBodySchema.ts
 import { z as z26 } from "zod";
 var postRoutinesRequestBodySchema = z26.object({
-  routine: z26.object({
-    title: z26.string().describe("The title of the routine.").optional(),
-    folder_id: z26.number().describe('The folder id the routine should be added to. Pass null to insert the routine into default "My Routines" folder').nullable().nullish(),
-    notes: z26.string().describe("Additional notes for the routine.").optional(),
-    exercises: z26.array(z26.lazy(() => postRoutinesRequestExerciseSchema)).optional()
-  }).optional()
+  "routine": z26.optional(z26.object({
+    "title": z26.optional(z26.string().describe("The title of the routine.")),
+    "folder_id": z26.number().describe('The folder id the routine should be added to. Pass null to insert the routine into default "My Routines" folder').nullish(),
+    "notes": z26.optional(z26.string().describe("Additional notes for the routine.")),
+    "exercises": z26.optional(z26.array(z26.lazy(() => postRoutinesRequestExerciseSchema)))
+  }))
 });
 
 // src/generated/client/schemas/postV1RoutineFoldersSchema.ts
@@ -809,33 +830,27 @@ import { z as z27 } from "zod";
 var postV1RoutineFoldersHeaderParamsSchema = z27.object({
   "api-key": z27.string().uuid()
 });
-var postV1RoutineFolders201Schema = z27.lazy(() => routineFolderSchema);
 var postV1RoutineFolders400Schema = z27.object({
-  error: z27.string().describe("Error message").optional()
+  "error": z27.optional(z27.string().describe("Error message"))
 });
-var postV1RoutineFoldersMutationRequestSchema = z27.lazy(() => postRoutineFolderRequestBodySchema);
-var postV1RoutineFoldersMutationResponseSchema = z27.lazy(() => postV1RoutineFolders201Schema);
 
 // src/generated/client/schemas/postV1RoutinesSchema.ts
 import { z as z28 } from "zod";
 var postV1RoutinesHeaderParamsSchema = z28.object({
   "api-key": z28.string().uuid()
 });
-var postV1Routines201Schema = z28.lazy(() => routineSchema);
 var postV1Routines400Schema = z28.object({
-  error: z28.string().describe("Error message").optional()
+  "error": z28.optional(z28.string().describe("Error message"))
 });
 var postV1Routines403Schema = z28.object({
-  error: z28.string().describe("Error message").optional()
+  "error": z28.optional(z28.string().describe("Error message"))
 });
-var postV1RoutinesMutationRequestSchema = z28.lazy(() => postRoutinesRequestBodySchema);
-var postV1RoutinesMutationResponseSchema = z28.lazy(() => postV1Routines201Schema);
 
 // src/generated/client/schemas/webhookRequestBodySchema.ts
 import { z as z29 } from "zod";
 var webhookRequestBodySchema = z29.object({
-  authToken: z29.string().describe("The auth token that will be send as Authorization header in the webhook.").optional(),
-  url: z29.string().describe("The webhook URL.").optional()
+  "authToken": z29.optional(z29.string().describe("The auth token that will be send as Authorization header in the webhook.")),
+  "url": z29.optional(z29.string().describe("The webhook URL."))
 });
 
 // src/generated/client/schemas/postV1WebhookSubscriptionSchema.ts
@@ -845,43 +860,41 @@ var postV1WebhookSubscriptionHeaderParamsSchema = z30.object({
 });
 var postV1WebhookSubscription201Schema = z30.any();
 var postV1WebhookSubscription400Schema = z30.object({
-  error: z30.string().describe("Error message").optional()
+  "error": z30.optional(z30.string().describe("Error message"))
 });
-var postV1WebhookSubscriptionMutationRequestSchema = z30.lazy(() => webhookRequestBodySchema);
-var postV1WebhookSubscriptionMutationResponseSchema = z30.lazy(() => postV1WebhookSubscription201Schema);
 
 // src/generated/client/schemas/postWorkoutsRequestSetSchema.ts
 import { z as z31 } from "zod";
 var postWorkoutsRequestSetSchema = z31.object({
-  type: z31.enum(["warmup", "normal", "failure", "dropset"]).describe("The type of the set.").optional(),
-  weight_kg: z31.number().describe("The weight in kilograms.").nullable().nullish(),
-  reps: z31.number().int().describe("The number of repetitions.").nullable().nullish(),
-  distance_meters: z31.number().int().describe("The distance in meters.").nullable().nullish(),
-  duration_seconds: z31.number().int().describe("The duration in seconds.").nullable().nullish(),
-  custom_metric: z31.number().describe("A custom metric for the set. Currently used for steps and floors.").nullable().nullish(),
-  rpe: z31.union([z31.literal(6), z31.literal(7), z31.literal(7.5), z31.literal(8), z31.literal(8.5), z31.literal(9), z31.literal(9.5), z31.literal(10)]).describe("The Rating of Perceived Exertion (RPE).").nullable().nullish()
+  "type": z31.optional(z31.enum(["warmup", "normal", "failure", "dropset"]).describe("The type of the set.")),
+  "weight_kg": z31.number().describe("The weight in kilograms.").nullish(),
+  "reps": z31.number().int().describe("The number of repetitions.").nullish(),
+  "distance_meters": z31.number().int().describe("The distance in meters.").nullish(),
+  "duration_seconds": z31.number().int().describe("The duration in seconds.").nullish(),
+  "custom_metric": z31.number().describe("A custom metric for the set. Currently used for steps and floors.").nullish(),
+  "rpe": z31.union([z31.literal(6), z31.literal(7), z31.literal(7.5), z31.literal(8), z31.literal(8.5), z31.literal(9), z31.literal(9.5), z31.literal(10)]).describe("The Rating of Perceived Exertion (RPE).").nullish()
 });
 
 // src/generated/client/schemas/postWorkoutsRequestExerciseSchema.ts
 import { z as z32 } from "zod";
 var postWorkoutsRequestExerciseSchema = z32.object({
-  exercise_template_id: z32.string().describe("The ID of the exercise template.").optional(),
-  superset_id: z32.number().int().describe("The ID of the superset.").nullable().nullish(),
-  notes: z32.string().describe("Additional notes for the exercise.").nullable().nullish(),
-  sets: z32.array(z32.lazy(() => postWorkoutsRequestSetSchema)).optional()
+  "exercise_template_id": z32.optional(z32.string().describe("The ID of the exercise template.")),
+  "superset_id": z32.number().int().describe("The ID of the superset.").nullish(),
+  "notes": z32.string().describe("Additional notes for the exercise.").nullish(),
+  "sets": z32.optional(z32.array(z32.lazy(() => postWorkoutsRequestSetSchema)))
 });
 
 // src/generated/client/schemas/postWorkoutsRequestBodySchema.ts
 import { z as z33 } from "zod";
 var postWorkoutsRequestBodySchema = z33.object({
-  workout: z33.object({
-    title: z33.string().describe("The title of the workout.").optional(),
-    description: z33.string().describe("A description for the workout workout.").nullable().nullish(),
-    start_time: z33.string().describe("The time the workout started.").optional(),
-    end_time: z33.string().describe("The time the workout ended.").optional(),
-    is_private: z33.boolean().describe("A boolean indicating if the workout is private.").optional(),
-    exercises: z33.array(z33.lazy(() => postWorkoutsRequestExerciseSchema)).optional()
-  }).optional()
+  "workout": z33.optional(z33.object({
+    "title": z33.optional(z33.string().describe("The title of the workout.")),
+    "description": z33.string().describe("A description for the workout workout.").nullish(),
+    "start_time": z33.optional(z33.string().describe("The time the workout started.")),
+    "end_time": z33.optional(z33.string().describe("The time the workout ended.")),
+    "is_private": z33.optional(z33.boolean().describe("A boolean indicating if the workout is private.")),
+    "exercises": z33.optional(z33.array(z33.lazy(() => postWorkoutsRequestExerciseSchema)))
+  }))
 });
 
 // src/generated/client/schemas/postV1WorkoutsSchema.ts
@@ -889,80 +902,71 @@ import { z as z34 } from "zod";
 var postV1WorkoutsHeaderParamsSchema = z34.object({
   "api-key": z34.string().uuid()
 });
-var postV1Workouts201Schema = z34.lazy(() => workoutSchema);
 var postV1Workouts400Schema = z34.object({
-  error: z34.string().describe("Error message").optional()
+  "error": z34.optional(z34.string().describe("Error message"))
 });
-var postV1WorkoutsMutationRequestSchema = z34.lazy(() => postWorkoutsRequestBodySchema);
-var postV1WorkoutsMutationResponseSchema = z34.lazy(() => postV1Workouts201Schema);
 
 // src/generated/client/schemas/putRoutinesRequestSetSchema.ts
 import { z as z35 } from "zod";
 var putRoutinesRequestSetSchema = z35.object({
-  type: z35.enum(["warmup", "normal", "failure", "dropset"]).describe("The type of the set.").optional(),
-  weight_kg: z35.number().describe("The weight in kilograms.").nullable().nullish(),
-  reps: z35.number().int().describe("The number of repetitions.").nullable().nullish(),
-  distance_meters: z35.number().int().describe("The distance in meters.").nullable().nullish(),
-  duration_seconds: z35.number().int().describe("The duration in seconds.").nullable().nullish(),
-  custom_metric: z35.number().describe("A custom metric for the set. Currently used for steps and floors.").nullable().nullish(),
-  rep_range: z35.object({
-    start: z35.number().describe("Starting rep count for the range").nullable().nullish(),
-    end: z35.number().describe("Ending rep count for the range").nullable().nullish()
-  }).describe("Range of reps for the set, if applicable").nullable().nullish()
+  "type": z35.optional(z35.enum(["warmup", "normal", "failure", "dropset"]).describe("The type of the set.")),
+  "weight_kg": z35.number().describe("The weight in kilograms.").nullish(),
+  "reps": z35.number().int().describe("The number of repetitions.").nullish(),
+  "distance_meters": z35.number().int().describe("The distance in meters.").nullish(),
+  "duration_seconds": z35.number().int().describe("The duration in seconds.").nullish(),
+  "custom_metric": z35.number().describe("A custom metric for the set. Currently used for steps and floors.").nullish(),
+  "rep_range": z35.object({
+    "start": z35.number().describe("Starting rep count for the range").nullish(),
+    "end": z35.number().describe("Ending rep count for the range").nullish()
+  }).describe("Range of reps for the set, if applicable").nullish()
 });
 
 // src/generated/client/schemas/putRoutinesRequestExerciseSchema.ts
 import { z as z36 } from "zod";
 var putRoutinesRequestExerciseSchema = z36.object({
-  exercise_template_id: z36.string().describe("The ID of the exercise template.").optional(),
-  superset_id: z36.number().int().describe("The ID of the superset.").nullable().nullish(),
-  rest_seconds: z36.number().int().describe("The rest time in seconds.").nullable().nullish(),
-  notes: z36.string().describe("Additional notes for the exercise.").nullable().nullish(),
-  sets: z36.array(z36.lazy(() => putRoutinesRequestSetSchema)).optional()
+  "exercise_template_id": z36.optional(z36.string().describe("The ID of the exercise template.")),
+  "superset_id": z36.number().int().describe("The ID of the superset.").nullish(),
+  "rest_seconds": z36.number().int().describe("The rest time in seconds.").nullish(),
+  "notes": z36.string().describe("Additional notes for the exercise.").nullish(),
+  "sets": z36.optional(z36.array(z36.lazy(() => putRoutinesRequestSetSchema)))
 });
 
 // src/generated/client/schemas/putRoutinesRequestBodySchema.ts
 import { z as z37 } from "zod";
 var putRoutinesRequestBodySchema = z37.object({
-  routine: z37.object({
-    title: z37.string().describe("The title of the routine.").optional(),
-    notes: z37.string().describe("Additional notes for the routine.").nullable().nullish(),
-    exercises: z37.array(z37.lazy(() => putRoutinesRequestExerciseSchema)).optional()
-  }).optional()
+  "routine": z37.optional(z37.object({
+    "title": z37.optional(z37.string().describe("The title of the routine.")),
+    "notes": z37.string().describe("Additional notes for the routine.").nullish(),
+    "exercises": z37.optional(z37.array(z37.lazy(() => putRoutinesRequestExerciseSchema)))
+  }))
 });
 
 // src/generated/client/schemas/putV1RoutinesRoutineidSchema.ts
 import { z as z38 } from "zod";
 var putV1RoutinesRoutineidPathParamsSchema = z38.object({
-  routineId: z38.any()
+  "routineId": z38.any()
 });
 var putV1RoutinesRoutineidHeaderParamsSchema = z38.object({
   "api-key": z38.string().uuid()
 });
-var putV1RoutinesRoutineid200Schema = z38.lazy(() => routineSchema);
 var putV1RoutinesRoutineid400Schema = z38.object({
-  error: z38.string().describe("Error message").optional()
+  "error": z38.optional(z38.string().describe("Error message"))
 });
 var putV1RoutinesRoutineid404Schema = z38.object({
-  error: z38.string().describe("Error message").optional()
+  "error": z38.optional(z38.string().describe("Error message"))
 });
-var putV1RoutinesRoutineidMutationRequestSchema = z38.lazy(() => putRoutinesRequestBodySchema);
-var putV1RoutinesRoutineidMutationResponseSchema = z38.lazy(() => putV1RoutinesRoutineid200Schema);
 
 // src/generated/client/schemas/putV1WorkoutsWorkoutidSchema.ts
 import { z as z39 } from "zod";
 var putV1WorkoutsWorkoutidPathParamsSchema = z39.object({
-  workoutId: z39.any()
+  "workoutId": z39.any()
 });
 var putV1WorkoutsWorkoutidHeaderParamsSchema = z39.object({
   "api-key": z39.string().uuid()
 });
-var putV1WorkoutsWorkoutid200Schema = z39.lazy(() => workoutSchema);
 var putV1WorkoutsWorkoutid400Schema = z39.object({
-  error: z39.string().describe("Error message").optional()
+  "error": z39.optional(z39.string().describe("Error message"))
 });
-var putV1WorkoutsWorkoutidMutationRequestSchema = z39.lazy(() => postWorkoutsRequestBodySchema);
-var putV1WorkoutsWorkoutidMutationResponseSchema = z39.lazy(() => putV1WorkoutsWorkoutid200Schema);
 
 // src/tools/webhooks.ts
 var webhookUrlSchema = z40.string().url().refine(
@@ -996,6 +1000,11 @@ function registerWebhookTools(server2, hevyClient2) {
     "Get the current webhook subscription for this account. Returns the webhook URL and auth token if a subscription exists.",
     {},
     withErrorHandling(async () => {
+      if (!hevyClient2) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
       const data = await hevyClient2.getWebhookSubscription();
       if (!data) {
         return createEmptyResponse(
@@ -1017,6 +1026,11 @@ function registerWebhookTools(server2, hevyClient2) {
       )
     },
     withErrorHandling(async ({ url, authToken }) => {
+      if (!hevyClient2) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
       const requestBody = webhookRequestBodySchema.parse({
         url,
         authToken
@@ -1035,6 +1049,11 @@ function registerWebhookTools(server2, hevyClient2) {
     "Delete the current webhook subscription for this account. This will stop all webhook notifications.",
     {},
     withErrorHandling(async () => {
+      if (!hevyClient2) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
       const data = await hevyClient2.deleteWebhookSubscription();
       if (!data) {
         return createEmptyResponse(
@@ -1057,6 +1076,11 @@ function registerWorkoutTools(server2, hevyClient2) {
       pageSize: z41.coerce.number().int().gte(1).lte(10).default(5)
     },
     withErrorHandling(async ({ page, pageSize }) => {
+      if (!hevyClient2) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
       const data = await hevyClient2.getWorkouts({
         page,
         pageSize
@@ -1077,6 +1101,11 @@ function registerWorkoutTools(server2, hevyClient2) {
       workoutId: z41.string().min(1)
     },
     withErrorHandling(async ({ workoutId }) => {
+      if (!hevyClient2) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
       const data = await hevyClient2.getWorkout(workoutId);
       if (!data) {
         return createEmptyResponse(`Workout with ID ${workoutId} not found`);
@@ -1090,6 +1119,11 @@ function registerWorkoutTools(server2, hevyClient2) {
     "Get the total number of workouts on the account. Useful for pagination or statistics.",
     {},
     withErrorHandling(async () => {
+      if (!hevyClient2) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
       const data = await hevyClient2.getWorkoutCount();
       const count = data ? data.workoutCount || 0 : 0;
       return createJsonResponse({ count });
@@ -1104,6 +1138,11 @@ function registerWorkoutTools(server2, hevyClient2) {
       since: z41.string().default("1970-01-01T00:00:00Z")
     },
     withErrorHandling(async ({ page, pageSize, since }) => {
+      if (!hevyClient2) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
       const data = await hevyClient2.getWorkoutEvents({
         page,
         pageSize,
@@ -1155,6 +1194,11 @@ function registerWorkoutTools(server2, hevyClient2) {
         isPrivate,
         exercises
       }) => {
+        if (!hevyClient2) {
+          throw new Error(
+            "API client not initialized. Please provide HEVY_API_KEY."
+          );
+        }
         const requestBody = {
           workout: {
             title,
@@ -1274,7 +1318,7 @@ function registerWorkoutTools(server2, hevyClient2) {
 
 // src/utils/config.ts
 function parseConfig(argv, env) {
-  let apiKey2 = "";
+  let apiKey = "";
   const apiKeyArgPatterns = [
     /^--hevy-api-key=(.+)$/i,
     /^--hevyApiKey=(.+)$/i,
@@ -1284,14 +1328,14 @@ function parseConfig(argv, env) {
     for (const pattern of apiKeyArgPatterns) {
       const m = raw.match(pattern);
       if (m) {
-        apiKey2 = m[1];
+        apiKey = m[1];
         break;
       }
     }
-    if (apiKey2) break;
+    if (apiKey) break;
   }
-  if (!apiKey2) {
-    apiKey2 = env.HEVY_API_KEY || "";
+  if (!apiKey) {
+    apiKey = env.HEVY_API_KEY || "";
   }
   const transportMode = argv.includes("--http") || env.MCP_TRANSPORT === "http" ? "http" : "stdio";
   const httpPort = Number.parseInt(env.MCP_HTTP_PORT || "3000", 10);
@@ -1299,7 +1343,7 @@ function parseConfig(argv, env) {
   const enableDnsRebindingProtection = env.MCP_DNS_REBINDING_PROTECTION === "true";
   const allowedHosts = env.MCP_ALLOWED_HOSTS?.split(",").map((h) => h.trim()).filter(Boolean) || ["127.0.0.1"];
   return {
-    apiKey: apiKey2,
+    apiKey,
     transportMode,
     httpHost,
     httpPort,
@@ -1307,10 +1351,10 @@ function parseConfig(argv, env) {
     allowedHosts
   };
 }
-function assertApiKey(apiKey2) {
-  if (!apiKey2) {
+function assertApiKey(apiKey) {
+  if (!apiKey) {
     console.error(
-      "Hevy API key is required. Provide via HEVY_API_KEY env variable or --hevy-api-key=YOUR_KEY command argument."
+      "Hevy API key is required. Provide via HEVY_API_KEY env variable, --hevy-api-key=YOUR_KEY command argument, or ?HEVY_API_KEY=YOUR_KEY query parameter."
     );
     process.exit(1);
   }
@@ -1322,318 +1366,235 @@ import axios from "axios";
 // src/generated/client/api/deleteV1WebhookSubscription.ts
 import fetch from "@kubb/plugin-client/clients/axios";
 function getDeleteV1WebhookSubscriptionUrl() {
-  return `/v1/webhook-subscription`;
+  const res = { method: "DELETE", url: `/v1/webhook-subscription` };
+  return res;
 }
 async function deleteV1WebhookSubscription(headers, config = {}) {
   const { client: request = fetch, ...requestConfig } = config;
-  const res = await request({
-    method: "DELETE",
-    url: getDeleteV1WebhookSubscriptionUrl().toString(),
-    ...requestConfig,
-    headers: { ...headers, ...requestConfig.headers }
-  });
+  const res = await request({ method: "DELETE", url: getDeleteV1WebhookSubscriptionUrl().url.toString(), ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
   return res.data;
 }
 
 // src/generated/client/api/getV1ExerciseTemplates.ts
 import fetch2 from "@kubb/plugin-client/clients/axios";
 function getGetV1ExerciseTemplatesUrl() {
-  return `/v1/exercise_templates`;
+  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().toString(),
-    params,
-    ...requestConfig,
-    headers: { ...headers, ...requestConfig.headers }
-  });
+  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) {
-  return `/v1/exercise_templates/${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).toString(),
-    ...requestConfig,
-    headers: { ...headers, ...requestConfig.headers }
-  });
+  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() {
-  return `/v1/routine_folders`;
+  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().toString(),
-    params,
-    ...requestConfig,
-    headers: { ...headers, ...requestConfig.headers }
-  });
+  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) {
-  return `/v1/routine_folders/${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).toString(),
-    ...requestConfig,
-    headers: { ...headers, ...requestConfig.headers }
-  });
+  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() {
-  return `/v1/routines`;
+  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().toString(),
-    params,
-    ...requestConfig,
-    headers: { ...headers, ...requestConfig.headers }
-  });
+  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) {
-  return `/v1/routines/${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).toString(),
-    ...requestConfig,
-    headers: { ...headers, ...requestConfig.headers }
-  });
+  const res = await request({ method: "GET", url: getGetV1RoutinesRoutineidUrl(routineId).url.toString(), ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
   return res.data;
 }
 
 // src/generated/client/api/getV1WebhookSubscription.ts
 import fetch8 from "@kubb/plugin-client/clients/axios";
 function getGetV1WebhookSubscriptionUrl() {
-  return `/v1/webhook-subscription`;
+  const res = { method: "GET", url: `/v1/webhook-subscription` };
+  return res;
 }
 async function getV1WebhookSubscription(headers, config = {}) {
   const { client: request = fetch8, ...requestConfig } = config;
-  const res = await request({
-    method: "GET",
-    url: getGetV1WebhookSubscriptionUrl().toString(),
-    ...requestConfig,
-    headers: { ...headers, ...requestConfig.headers }
-  });
+  const res = await request({ method: "GET", url: getGetV1WebhookSubscriptionUrl().url.toString(), ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
   return res.data;
 }
 
 // src/generated/client/api/getV1Workouts.ts
 import fetch9 from "@kubb/plugin-client/clients/axios";
 function getGetV1WorkoutsUrl() {
-  return `/v1/workouts`;
+  const res = { method: "GET", url: `/v1/workouts` };
+  return res;
 }
 async function getV1Workouts(headers, params, config = {}) {
   const { client: request = fetch9, ...requestConfig } = config;
-  const res = await request({
-    method: "GET",
-    url: getGetV1WorkoutsUrl().toString(),
-    params,
-    ...requestConfig,
-    headers: { ...headers, ...requestConfig.headers }
-  });
+  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 fetch10 from "@kubb/plugin-client/clients/axios";
 function getGetV1WorkoutsCountUrl() {
-  return `/v1/workouts/count`;
+  const res = { method: "GET", url: `/v1/workouts/count` };
+  return res;
 }
 async function getV1WorkoutsCount(headers, config = {}) {
   const { client: request = fetch10, ...requestConfig } = config;
-  const res = await request({
-    method: "GET",
-    url: getGetV1WorkoutsCountUrl().toString(),
-    ...requestConfig,
-    headers: { ...headers, ...requestConfig.headers }
-  });
+  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 fetch11 from "@kubb/plugin-client/clients/axios";
 function getGetV1WorkoutsEventsUrl() {
-  return `/v1/workouts/events`;
+  const res = { method: "GET", url: `/v1/workouts/events` };
+  return res;
 }
 async function getV1WorkoutsEvents(headers, params, config = {}) {
   const { client: request = fetch11, ...requestConfig } = config;
-  const res = await request({
-    method: "GET",
-    url: getGetV1WorkoutsEventsUrl().toString(),
-    params,
-    ...requestConfig,
-    headers: { ...headers, ...requestConfig.headers }
-  });
+  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 fetch12 from "@kubb/plugin-client/clients/axios";
 function getGetV1WorkoutsWorkoutidUrl(workoutId) {
-  return `/v1/workouts/${workoutId}`;
+  const res = { method: "GET", url: `/v1/workouts/${workoutId}` };
+  return res;
 }
 async function getV1WorkoutsWorkoutid(workoutId, headers, config = {}) {
   const { client: request = fetch12, ...requestConfig } = config;
-  const res = await request({
-    method: "GET",
-    url: getGetV1WorkoutsWorkoutidUrl(workoutId).toString(),
-    ...requestConfig,
-    headers: { ...headers, ...requestConfig.headers }
-  });
+  const res = await request({ method: "GET", url: getGetV1WorkoutsWorkoutidUrl(workoutId).url.toString(), ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
   return res.data;
 }
 
 // src/generated/client/api/postV1RoutineFolders.ts
 import fetch13 from "@kubb/plugin-client/clients/axios";
 function getPostV1RoutineFoldersUrl() {
-  return `/v1/routine_folders`;
+  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().toString(),
-    data: requestData,
-    ...requestConfig,
-    headers: { ...headers, ...requestConfig.headers }
-  });
+  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() {
-  return `/v1/routines`;
+  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().toString(),
-    data: requestData,
-    ...requestConfig,
-    headers: { ...headers, ...requestConfig.headers }
-  });
+  const res = await request({ method: "POST", url: getPostV1RoutinesUrl().url.toString(), data: requestData, ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
   return res.data;
 }
 
 // src/generated/client/api/postV1WebhookSubscription.ts
 import fetch15 from "@kubb/plugin-client/clients/axios";
 function getPostV1WebhookSubscriptionUrl() {
-  return `/v1/webhook-subscription`;
+  const res = { method: "POST", url: `/v1/webhook-subscription` };
+  return res;
 }
 async function postV1WebhookSubscription(headers, data, config = {}) {
   const { client: request = fetch15, ...requestConfig } = config;
   const requestData = data;
-  const res = await request({
-    method: "POST",
-    url: getPostV1WebhookSubscriptionUrl().toString(),
-    data: requestData,
-    ...requestConfig,
-    headers: { ...headers, ...requestConfig.headers }
-  });
+  const res = await request({ method: "POST", url: getPostV1WebhookSubscriptionUrl().url.toString(), data: requestData, ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
   return res.data;
 }
 
 // src/generated/client/api/postV1Workouts.ts
 import fetch16 from "@kubb/plugin-client/clients/axios";
 function getPostV1WorkoutsUrl() {
-  return `/v1/workouts`;
+  const res = { method: "POST", url: `/v1/workouts` };
+  return res;
 }
 async function postV1Workouts(headers, data, config = {}) {
   const { client: request = fetch16, ...requestConfig } = config;
   const requestData = data;
-  const res = await request({
-    method: "POST",
-    url: getPostV1WorkoutsUrl().toString(),
-    data: requestData,
-    ...requestConfig,
-    headers: { ...headers, ...requestConfig.headers }
-  });
+  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 fetch17 from "@kubb/plugin-client/clients/axios";
 function getPutV1RoutinesRoutineidUrl(routineId) {
-  return `/v1/routines/${routineId}`;
+  const res = { method: "PUT", url: `/v1/routines/${routineId}` };
+  return res;
 }
 async function putV1RoutinesRoutineid(routineId, headers, data, config = {}) {
   const { client: request = fetch17, ...requestConfig } = config;
   const requestData = data;
-  const res = await request({
-    method: "PUT",
-    url: getPutV1RoutinesRoutineidUrl(routineId).toString(),
-    data: requestData,
-    ...requestConfig,
-    headers: { ...headers, ...requestConfig.headers }
-  });
+  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 fetch18 from "@kubb/plugin-client/clients/axios";
 function getPutV1WorkoutsWorkoutidUrl(workoutId) {
-  return `/v1/workouts/${workoutId}`;
+  const res = { method: "PUT", url: `/v1/workouts/${workoutId}` };
+  return res;
 }
 async function putV1WorkoutsWorkoutid(workoutId, headers, data, config = {}) {
   const { client: request = fetch18, ...requestConfig } = config;
   const requestData = data;
-  const res = await request({
-    method: "PUT",
-    url: getPutV1WorkoutsWorkoutidUrl(workoutId).toString(),
-    data: requestData,
-    ...requestConfig,
-    headers: { ...headers, ...requestConfig.headers }
-  });
+  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(apiKey2, baseUrl = "https://api.hevyapp.com") {
+function createClient(apiKey, baseUrl = "https://api.hevyapp.com") {
   const axiosInstance = axios.create({
     baseURL: baseUrl,
     headers: {
-      "api-key": apiKey2
+      "api-key": apiKey
     }
   });
   const headers = {
-    "api-key": apiKey2
+    "api-key": apiKey
   };
   const client = axiosInstance;
   return {
@@ -1672,8 +1633,8 @@ function createClient(apiKey2, baseUrl = "https://api.hevyapp.com") {
 }
 
 // src/utils/hevyClient.ts
-function createClient2(apiKey2, baseUrl) {
-  return createClient(apiKey2, baseUrl);
+function createClient2(apiKey, baseUrl) {
+  return createClient(apiKey, baseUrl);
 }
 
 // src/utils/httpServer.ts
@@ -1701,13 +1662,46 @@ function createHttpServer(server2, options) {
   const port = options?.port || 3e3;
   const host = options?.host || "127.0.0.1";
   app.use(express.json());
+  app.use("/mcp", (req, res, next) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader(
+      "Access-Control-Allow-Headers",
+      "Content-Type, mcp-session-id"
+    );
+    res.setHeader(
+      "Access-Control-Expose-Headers",
+      "mcp-session-id, mcp-protocol-version"
+    );
+    if (req.method === "OPTIONS") {
+      res.status(204).end();
+      return;
+    }
+    next();
+  });
   app.post("/mcp", async (req, res) => {
     const sessionId = req.headers["mcp-session-id"];
     let transport;
     if (sessionId && transports.has(sessionId)) {
-      transport = transports.get(sessionId).transport;
-      transports.get(sessionId).lastActivity = Date.now();
+      const existingSession = transports.get(sessionId);
+      if (!existingSession) {
+        res.status(400).json({
+          jsonrpc: "2.0",
+          error: {
+            code: -32e3,
+            message: "Bad Request: Session lookup failed"
+          },
+          id: null
+        });
+        return;
+      }
+      transport = existingSession.transport;
+      existingSession.lastActivity = Date.now();
     } else if (!sessionId && isInitializeRequest(req.body)) {
+      const queryApiKey = req.query.HEVY_API_KEY;
+      if (queryApiKey && options?.onFirstRequestApiKey) {
+        options.onFirstRequestApiKey(queryApiKey);
+      }
       transport = new StreamableHTTPServerTransport({
         sessionIdGenerator: () => randomUUID(),
         onsessioninitialized: (sessionId2) => {
@@ -1743,7 +1737,9 @@ function createHttpServer(server2, options) {
       return;
     }
     const transport = transports.get(sessionId)?.transport;
-    await transport.handleRequest(req, res);
+    if (transport) {
+      await transport.handleRequest(req, res);
+    }
   };
   app.get("/mcp", handleSessionRequest);
   app.delete("/mcp", handleSessionRequest);
@@ -1784,9 +1780,23 @@ var server = new McpServer({
   name,
   version
 });
-assertApiKey(cfg.apiKey);
-var apiKey = cfg.apiKey;
-var hevyClient = createClient2(apiKey, HEVY_API_BASEURL);
+var hevyClient = null;
+function initializeClient(apiKey) {
+  if (!hevyClient) {
+    assertApiKey(apiKey);
+    hevyClient = createClient2(apiKey, HEVY_API_BASEURL);
+    console.log("Hevy client initialized with API key");
+  }
+}
+if (cfg.transportMode === "stdio") {
+  initializeClient(cfg.apiKey);
+} else if (cfg.apiKey) {
+  initializeClient(cfg.apiKey);
+} else {
+  console.log(
+    "Starting in HTTP mode without API key. Waiting for API key via query parameter on first request."
+  );
+}
 registerWorkoutTools(server, hevyClient);
 registerRoutineTools(server, hevyClient);
 registerTemplateTools(server, hevyClient);
@@ -1801,7 +1811,18 @@ async function runServer() {
       port: cfg.httpPort,
       host: cfg.httpHost,
       enableDnsRebindingProtection: cfg.enableDnsRebindingProtection,
-      allowedHosts: cfg.allowedHosts
+      allowedHosts: cfg.allowedHosts,
+      // Callback to handle API key from query params
+      onFirstRequestApiKey: (apiKey) => {
+        if (!hevyClient) {
+          initializeClient(apiKey);
+          registerWorkoutTools(server, hevyClient);
+          registerRoutineTools(server, hevyClient);
+          registerTemplateTools(server, hevyClient);
+          registerFolderTools(server, hevyClient);
+          registerWebhookTools(server, hevyClient);
+        }
+      }
     });
     await httpServer.startServer();
   } else {