hevy-mcp 1.10.16 → 1.12.3

package/dist/index.js

@@ -4,12 +4,14 @@
 
 // src/index.ts
 import "@dotenvx/dotenvx/config";
+import { fileURLToPath } from "url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z42 } from "zod";
 
 // package.json
 var name = "hevy-mcp";
-var version = "1.10.15";
+var version = "1.12.2";
 
 // src/tools/folders.ts
 import { z } from "zod";
@@ -53,9 +55,9 @@ function determineErrorType(error, message) {
   return "UNKNOWN_ERROR" /* UNKNOWN_ERROR */;
 }
 function withErrorHandling(fn, context) {
-  return (async (...args2) => {
+  return (async (...args) => {
     try {
-      return await fn(...args2);
+      return await fn(...args);
     } catch (error) {
       return createErrorResponse(error, context);
     }
@@ -188,8 +190,8 @@ function createEmptyResponse(message = "No data found") {
 }
 
 // src/tools/folders.ts
-function registerFolderTools(server2, hevyClient2) {
-  server2.tool(
+function registerFolderTools(server, hevyClient) {
+  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.",
     {
@@ -198,7 +200,12 @@ function registerFolderTools(server2, hevyClient2) {
     },
     withErrorHandling(
       async ({ page, pageSize }) => {
-        const data = await hevyClient2.getRoutineFolders({
+        if (!hevyClient) {
+          throw new Error(
+            "API client not initialized. Please provide HEVY_API_KEY."
+          );
+        }
+        const data = await hevyClient.getRoutineFolders({
           page,
           pageSize
         });
@@ -215,14 +222,19 @@ function registerFolderTools(server2, hevyClient2) {
       "get-routine-folders"
     )
   );
-  server2.tool(
+  server.tool(
     "get-routine-folder",
     "Get complete details of a specific routine folder by its ID, including name, creation date, and associated routines.",
     {
       folderId: z.string().min(1)
     },
     withErrorHandling(async ({ folderId }) => {
-      const data = await hevyClient2.getRoutineFolder(folderId);
+      if (!hevyClient) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
+      const data = await hevyClient.getRoutineFolder(folderId);
       if (!data) {
         return createEmptyResponse(
           `Routine folder with ID ${folderId} not found`
@@ -232,14 +244,19 @@ function registerFolderTools(server2, hevyClient2) {
       return createJsonResponse(folder);
     }, "get-routine-folder")
   );
-  server2.tool(
+  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.",
     {
       name: z.string().min(1)
     },
     withErrorHandling(async ({ name: name2 }) => {
-      const data = await hevyClient2.createRoutineFolder({
+      if (!hevyClient) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
+      const data = await hevyClient.createRoutineFolder({
         routine_folder: {
           title: name2
         }
@@ -260,17 +277,22 @@ function registerFolderTools(server2, hevyClient2) {
 
 // src/tools/routines.ts
 import { z as z2 } from "zod";
-function registerRoutineTools(server2, hevyClient2) {
-  server2.tool(
+function registerRoutineTools(server, hevyClient) {
+  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.",
     {
       page: z2.coerce.number().int().gte(1).default(1),
       pageSize: z2.coerce.number().int().gte(1).lte(10).default(5)
     },
-    withErrorHandling(async (args2) => {
-      const { page, pageSize } = args2;
-      const data = await hevyClient2.getRoutines({
+    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
       });
@@ -283,14 +305,19 @@ function registerRoutineTools(server2, hevyClient2) {
       return createJsonResponse(routines);
     }, "get-routines")
   );
-  server2.tool(
+  server.tool(
     "get-routine",
     "Get a routine by its ID using the direct endpoint. Returns all details for the specified routine.",
     {
       routineId: z2.string().min(1)
     },
     withErrorHandling(async ({ routineId }) => {
-      const data = await hevyClient2.getRoutineById(String(routineId));
+      if (!hevyClient) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
+      const data = await hevyClient.getRoutineById(String(routineId));
       if (!data || !data.routine) {
         return createEmptyResponse(`Routine with ID ${routineId} not found`);
       }
@@ -298,7 +325,7 @@ function registerRoutineTools(server2, hevyClient2) {
       return createJsonResponse(routine);
     }, "get-routine")
   );
-  server2.tool(
+  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.",
     {
@@ -324,9 +351,14 @@ function registerRoutineTools(server2, hevyClient2) {
         })
       )
     },
-    withErrorHandling(async (args2) => {
-      const { title, folderId, notes, exercises } = args2;
-      const data = await hevyClient2.createRoutine({
+    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,
@@ -363,7 +395,7 @@ function registerRoutineTools(server2, hevyClient2) {
       });
     }, "create-routine")
   );
-  server2.tool(
+  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.",
     {
@@ -389,9 +421,14 @@ function registerRoutineTools(server2, hevyClient2) {
         })
       )
     },
-    withErrorHandling(async (args2) => {
-      const { routineId, title, notes, exercises } = args2;
-      const data = await hevyClient2.updateRoutine(routineId, {
+    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,
@@ -431,8 +468,8 @@ function registerRoutineTools(server2, hevyClient2) {
 
 // src/tools/templates.ts
 import { z as z3 } from "zod";
-function registerTemplateTools(server2, hevyClient2) {
-  server2.tool(
+function registerTemplateTools(server, hevyClient) {
+  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.",
     {
@@ -441,7 +478,12 @@ function registerTemplateTools(server2, hevyClient2) {
     },
     withErrorHandling(
       async ({ page, pageSize }) => {
-        const data = await hevyClient2.getExerciseTemplates({
+        if (!hevyClient) {
+          throw new Error(
+            "API client not initialized. Please provide HEVY_API_KEY."
+          );
+        }
+        const data = await hevyClient.getExerciseTemplates({
           page,
           pageSize
         });
@@ -458,7 +500,7 @@ function registerTemplateTools(server2, hevyClient2) {
       "get-exercise-templates"
     )
   );
-  server2.tool(
+  server.tool(
     "get-exercise-template",
     "Get complete details of a specific exercise template by its ID, including name, category, equipment, muscle groups, and notes.",
     {
@@ -466,7 +508,12 @@ function registerTemplateTools(server2, hevyClient2) {
     },
     withErrorHandling(
       async ({ exerciseTemplateId }) => {
-        const data = await hevyClient2.getExerciseTemplate(exerciseTemplateId);
+        if (!hevyClient) {
+          throw new Error(
+            "API client not initialized. Please provide HEVY_API_KEY."
+          );
+        }
+        const data = await hevyClient.getExerciseTemplate(exerciseTemplateId);
         if (!data) {
           return createEmptyResponse(
             `Exercise template with ID ${exerciseTemplateId} not found`
@@ -486,9 +533,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 +544,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 +687,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 +698,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 +832,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 +862,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 +904,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(
@@ -990,13 +996,18 @@ var webhookUrlSchema = z40.string().url().refine(
     message: "Webhook URL cannot be localhost or loopback address"
   }
 );
-function registerWebhookTools(server2, hevyClient2) {
-  server2.tool(
+function registerWebhookTools(server, hevyClient) {
+  server.tool(
     "get-webhook-subscription",
     "Get the current webhook subscription for this account. Returns the webhook URL and auth token if a subscription exists.",
     {},
     withErrorHandling(async () => {
-      const data = await hevyClient2.getWebhookSubscription();
+      if (!hevyClient) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
+      const data = await hevyClient.getWebhookSubscription();
       if (!data) {
         return createEmptyResponse(
           "No webhook subscription found for this account"
@@ -1005,7 +1016,7 @@ function registerWebhookTools(server2, hevyClient2) {
       return createJsonResponse(data);
     }, "get-webhook-subscription")
   );
-  server2.tool(
+  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.",
     {
@@ -1017,11 +1028,16 @@ function registerWebhookTools(server2, hevyClient2) {
       )
     },
     withErrorHandling(async ({ url, authToken }) => {
+      if (!hevyClient) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
       const requestBody = webhookRequestBodySchema.parse({
         url,
         authToken
       });
-      const data = await hevyClient2.createWebhookSubscription(requestBody);
+      const data = await hevyClient.createWebhookSubscription(requestBody);
       if (!data) {
         return createEmptyResponse(
           "Failed to create webhook subscription - please check your URL and try again"
@@ -1030,12 +1046,17 @@ function registerWebhookTools(server2, hevyClient2) {
       return createJsonResponse(data);
     }, "create-webhook-subscription")
   );
-  server2.tool(
+  server.tool(
     "delete-webhook-subscription",
     "Delete the current webhook subscription for this account. This will stop all webhook notifications.",
     {},
     withErrorHandling(async () => {
-      const data = await hevyClient2.deleteWebhookSubscription();
+      if (!hevyClient) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
+      const data = await hevyClient.deleteWebhookSubscription();
       if (!data) {
         return createEmptyResponse(
           "Failed to delete webhook subscription - no subscription may exist or there was a server error"
@@ -1048,8 +1069,8 @@ function registerWebhookTools(server2, hevyClient2) {
 
 // src/tools/workouts.ts
 import { z as z41 } from "zod";
-function registerWorkoutTools(server2, hevyClient2) {
-  server2.tool(
+function registerWorkoutTools(server, hevyClient) {
+  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.",
     {
@@ -1057,7 +1078,12 @@ function registerWorkoutTools(server2, hevyClient2) {
       pageSize: z41.coerce.number().int().gte(1).lte(10).default(5)
     },
     withErrorHandling(async ({ page, pageSize }) => {
-      const data = await hevyClient2.getWorkouts({
+      if (!hevyClient) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
+      const data = await hevyClient.getWorkouts({
         page,
         pageSize
       });
@@ -1070,14 +1096,19 @@ function registerWorkoutTools(server2, hevyClient2) {
       return createJsonResponse(workouts);
     }, "get-workouts")
   );
-  server2.tool(
+  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.",
     {
       workoutId: z41.string().min(1)
     },
     withErrorHandling(async ({ workoutId }) => {
-      const data = await hevyClient2.getWorkout(workoutId);
+      if (!hevyClient) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
+      const data = await hevyClient.getWorkout(workoutId);
       if (!data) {
         return createEmptyResponse(`Workout with ID ${workoutId} not found`);
       }
@@ -1085,17 +1116,22 @@ function registerWorkoutTools(server2, hevyClient2) {
       return createJsonResponse(workout);
     }, "get-workout")
   );
-  server2.tool(
+  server.tool(
     "get-workout-count",
     "Get the total number of workouts on the account. Useful for pagination or statistics.",
     {},
     withErrorHandling(async () => {
-      const data = await hevyClient2.getWorkoutCount();
+      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")
   );
-  server2.tool(
+  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.",
     {
@@ -1104,7 +1140,12 @@ function registerWorkoutTools(server2, hevyClient2) {
       since: z41.string().default("1970-01-01T00:00:00Z")
     },
     withErrorHandling(async ({ page, pageSize, since }) => {
-      const data = await hevyClient2.getWorkoutEvents({
+      if (!hevyClient) {
+        throw new Error(
+          "API client not initialized. Please provide HEVY_API_KEY."
+        );
+      }
+      const data = await hevyClient.getWorkoutEvents({
         page,
         pageSize,
         since
@@ -1118,7 +1159,7 @@ function registerWorkoutTools(server2, hevyClient2) {
       return createJsonResponse(events);
     }, "get-workout-events")
   );
-  server2.tool(
+  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.",
     {
@@ -1155,6 +1196,11 @@ function registerWorkoutTools(server2, hevyClient2) {
         isPrivate,
         exercises
       }) => {
+        if (!hevyClient) {
+          throw new Error(
+            "API client not initialized. Please provide HEVY_API_KEY."
+          );
+        }
         const requestBody = {
           workout: {
             title,
@@ -1178,7 +1224,7 @@ function registerWorkoutTools(server2, hevyClient2) {
             }))
           }
         };
-        const data = await hevyClient2.createWorkout(requestBody);
+        const data = await hevyClient.createWorkout(requestBody);
         if (!data) {
           return createEmptyResponse(
             "Failed to create workout: Server returned no data"
@@ -1193,7 +1239,7 @@ function registerWorkoutTools(server2, hevyClient2) {
       "create-workout"
     )
   );
-  server2.tool(
+  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.",
     {
@@ -1255,7 +1301,7 @@ function registerWorkoutTools(server2, hevyClient2) {
             }))
           }
         };
-        const data = await hevyClient2.updateWorkout(workoutId, requestBody);
+        const data = await hevyClient.updateWorkout(workoutId, requestBody);
         if (!data) {
           return createEmptyResponse(
             `Failed to update workout with ID ${workoutId}`
@@ -1274,7 +1320,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,33 +1330,23 @@ 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);
-  const httpHost = env.MCP_HTTP_HOST || "127.0.0.1";
-  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,
-    transportMode,
-    httpHost,
-    httpPort,
-    enableDnsRebindingProtection,
-    allowedHosts
+    apiKey
   };
 }
-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 it via the HEVY_API_KEY environment variable or the --hevy-api-key=YOUR_KEY command argument."
     );
     process.exit(1);
   }
@@ -1322,318 +1358,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,146 +1625,67 @@ function createClient(apiKey2, baseUrl = "https://api.hevyapp.com") {
 }
 
 // src/utils/hevyClient.ts
-function createClient2(apiKey2, baseUrl) {
-  return createClient(apiKey2, baseUrl);
-}
-
-// src/utils/httpServer.ts
-import { randomUUID } from "crypto";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
-import express from "express";
-var transports = /* @__PURE__ */ new Map();
-var SESSION_TIMEOUT = 30 * 60 * 1e3;
-setInterval(
-  () => {
-    const now = Date.now();
-    for (const [sessionId, session] of transports) {
-      if (now - session.lastActivity > SESSION_TIMEOUT) {
-        console.log(`Cleaning up abandoned session: ${sessionId}`);
-        session.transport.close?.();
-        transports.delete(sessionId);
-      }
-    }
-  },
-  5 * 60 * 1e3
-);
-function createHttpServer(server2, options) {
-  const app = express();
-  const port = options?.port || 3e3;
-  const host = options?.host || "127.0.0.1";
-  app.use(express.json());
-  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();
-    } else if (!sessionId && isInitializeRequest(req.body)) {
-      transport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: () => randomUUID(),
-        onsessioninitialized: (sessionId2) => {
-          transports.set(sessionId2, { transport, lastActivity: Date.now() });
-        },
-        // DNS rebinding protection configuration
-        enableDnsRebindingProtection: options?.enableDnsRebindingProtection ?? false,
-        allowedHosts: options?.allowedHosts || ["127.0.0.1"]
-      });
-      transport.onclose = () => {
-        if (transport.sessionId) {
-          transports.delete(transport.sessionId);
-        }
-      };
-      await server2.connect(transport);
-    } else {
-      res.status(400).json({
-        jsonrpc: "2.0",
-        error: {
-          code: -32e3,
-          message: "Bad Request: No valid session ID provided"
-        },
-        id: null
-      });
-      return;
-    }
-    await transport.handleRequest(req, res, req.body);
-  });
-  const handleSessionRequest = async (req, res) => {
-    const sessionId = req.headers["mcp-session-id"];
-    if (!sessionId || !transports.has(sessionId)) {
-      res.status(400).send("Invalid or missing session ID");
-      return;
-    }
-    const transport = transports.get(sessionId)?.transport;
-    await transport.handleRequest(req, res);
-  };
-  app.get("/mcp", handleSessionRequest);
-  app.delete("/mcp", handleSessionRequest);
-  app.get("/health", (_req, res) => {
-    res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-  });
-  const startServer = () => {
-    return new Promise((resolve, reject) => {
-      const httpServer = app.listen(port, host, () => {
-        console.log(`MCP HTTP server listening on http://${host}:${port}`);
-        console.log(`MCP endpoint: http://${host}:${port}/mcp`);
-        console.log(`Health check: http://${host}:${port}/health`);
-        resolve();
-      });
-      httpServer.on("error", (error) => {
-        reject(error);
-      });
-    });
-  };
-  return {
-    app,
-    startServer,
-    getActiveSessionsCount: () => transports.size,
-    closeAllSessions: () => {
-      for (const session of transports.values()) {
-        session.transport.close?.();
-      }
-      transports.clear();
-    }
-  };
+function createClient2(apiKey, baseUrl) {
+  return createClient(apiKey, baseUrl);
 }
 
 // src/index.ts
 var HEVY_API_BASEURL = "https://api.hevyapp.com";
-var args = process.argv.slice(2);
-var cfg = parseConfig(args, process.env);
-var server = new McpServer({
-  name,
-  version
-});
-assertApiKey(cfg.apiKey);
-var apiKey = cfg.apiKey;
-var hevyClient = createClient2(apiKey, HEVY_API_BASEURL);
-registerWorkoutTools(server, hevyClient);
-registerRoutineTools(server, hevyClient);
-registerTemplateTools(server, hevyClient);
-registerFolderTools(server, hevyClient);
-registerWebhookTools(server, hevyClient);
+var serverConfigSchema = z42.object({
+  apiKey: z42.string().min(1, "Hevy API key is required").describe("Your Hevy API key (available in the Hevy app settings).")
+});
+var configSchema = serverConfigSchema;
+function buildServer(apiKey) {
+  const server = new McpServer({
+    name,
+    version
+  });
+  const hevyClient = createClient2(apiKey, HEVY_API_BASEURL);
+  console.log("Hevy client initialized with API key");
+  registerWorkoutTools(server, hevyClient);
+  registerRoutineTools(server, hevyClient);
+  registerTemplateTools(server, hevyClient);
+  registerFolderTools(server, hevyClient);
+  registerWebhookTools(server, hevyClient);
+  return server;
+}
+function createServer({ config }) {
+  const { apiKey } = serverConfigSchema.parse(config);
+  const server = buildServer(apiKey);
+  return server.server;
+}
 async function runServer() {
-  if (cfg.transportMode === "http") {
-    console.log(
-      `Starting MCP server in HTTP mode on ${cfg.httpHost}:${cfg.httpPort}`
-    );
-    const httpServer = createHttpServer(server, {
-      port: cfg.httpPort,
-      host: cfg.httpHost,
-      enableDnsRebindingProtection: cfg.enableDnsRebindingProtection,
-      allowedHosts: cfg.allowedHosts
-    });
-    await httpServer.startServer();
-  } else {
-    console.log("Starting MCP server in stdio mode");
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
+  const args = process.argv.slice(2);
+  const cfg = parseConfig(args, process.env);
+  const apiKey = cfg.apiKey;
+  assertApiKey(apiKey);
+  const server = buildServer(apiKey);
+  console.log("Starting MCP server in stdio mode");
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+var isDirectExecution = (() => {
+  if (typeof process === "undefined" || !Array.isArray(process.argv)) {
+    return false;
+  }
+  if (typeof import.meta === "undefined" || !import.meta?.url) {
+    return false;
   }
+  try {
+    const modulePath = fileURLToPath(import.meta.url);
+    return process.argv[1] === modulePath;
+  } catch {
+    return false;
+  }
+})();
+if (isDirectExecution) {
+  runServer().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+  });
 }
-runServer().catch((error) => {
-  console.error("Fatal error in main():", error);
-  process.exit(1);
-});
+export {
+  configSchema,
+  createServer as default
+};
 //# sourceMappingURL=index.js.map