@etweisberg/garmin-connect-mcp 0.1.15 → 0.1.17

package/README.md

@@ -99,6 +99,14 @@ Session cookies expire after a few hours. Re-run the login flow when they do.
 | `get-body-battery` | Body battery charged/drained values |
 | `get-hrv`          | Heart rate variability data         |
 
+### Training & Recovery
+
+| Tool                     | Description                                      |
+| ------------------------ | ------------------------------------------------ |
+| `get-training-readiness` | Training readiness score (sleep, recovery, load) |
+| `get-sleep-stats`        | Sleep statistics over a date range               |
+| `get-hydration`          | Daily hydration/water intake data                |
+
 ### Weight / Records / Fitness
 
 | Tool                   | Description                           |
@@ -108,8 +116,29 @@ Session cookies expire after a few hours. Re-run the login flow when they do.
 | `get-fitness-stats`    | Aggregated activity stats by type     |
 | `get-vo2max`           | Latest VO2 Max estimate               |
 | `get-hr-zones-config`  | Heart rate zone boundaries            |
+| `get-power-zones`      | Power zone config for all sports      |
 | `get-user-profile`     | User profile and settings             |
 
+### Calendar, Goals & Badges
+
+| Tool                    | Description                                 |
+| ----------------------- | ------------------------------------------- |
+| `get-calendar`          | Monthly calendar with activities and events |
+| `get-goals`             | Active, future, or past fitness goals       |
+| `get-badges`            | All earned badges/achievements              |
+| `get-badge-leaderboard` | Badge leaderboard among connections         |
+
+### Workouts
+
+| Tool                   | Description                                        |
+| ---------------------- | -------------------------------------------------- |
+| `list-workouts`        | List saved workouts                                |
+| `get-workout`          | Get workout details (steps, segments)              |
+| `create-workout`       | Create a new workout (warmup, intervals, cooldown) |
+| `schedule-workout`     | Schedule a workout to a date (syncs to device)     |
+| `delete-workout`       | Delete a workout                                   |
+| `download-workout-fit` | Download a workout as a FIT file                   |
+
 ## Architecture
 
 ```

package/dist/garmin-client.js

@@ -142,6 +142,55 @@ export class GarminClient {
         }
         return Buffer.from(result.data, "base64");
     }
+    async post(path, body) {
+        await this.init();
+        const url = `/gc-api/${path}`;
+        const csrfToken = this.csrfToken;
+        const bodyStr = JSON.stringify(body);
+        const result = await this.page.evaluate(async ({ url, csrfToken, bodyStr, }) => {
+            const resp = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "connect-csrf-token": csrfToken,
+                    "Content-Type": "application/json",
+                    Accept: "application/json, */*",
+                },
+                body: bodyStr,
+            });
+            const text = await resp.text();
+            return { status: resp.status, body: text };
+        }, { url, csrfToken, bodyStr });
+        if (result.status === 204 || (result.status === 200 && !result.body)) {
+            return { noData: true, status: result.status, path };
+        }
+        if (result.status < 200 || result.status >= 300) {
+            throw new Error(`Garmin API ${result.status}: ${path} — ${result.body}`);
+        }
+        return JSON.parse(result.body);
+    }
+    async delete(path) {
+        await this.init();
+        const url = `/gc-api/${path}`;
+        const csrfToken = this.csrfToken;
+        const result = await this.page.evaluate(async ({ url, csrfToken }) => {
+            const resp = await fetch(url, {
+                method: "DELETE",
+                headers: {
+                    "connect-csrf-token": csrfToken,
+                    Accept: "*/*",
+                },
+            });
+            const text = await resp.text();
+            return { status: resp.status, body: text };
+        }, { url, csrfToken });
+        if (result.status === 204 || (result.status === 200 && !result.body)) {
+            return { noData: true, status: result.status, path };
+        }
+        if (result.status < 200 || result.status >= 300) {
+            throw new Error(`Garmin API ${result.status}: ${path} — ${result.body}`);
+        }
+        return result.body ? JSON.parse(result.body) : { success: true };
+    }
 }
 // Singleton client for reuse across tool calls
 let _sharedClient = null;

package/dist/index.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { registerTools } from "./tools.js";
+import { registerTools, registerResources } from "./tools.js";
 async function startMcpServer() {
     const server = new McpServer({
         name: "garmin-connect-mcp",
         version: "0.1.0",
     });
     registerTools(server);
+    registerResources(server);
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error("garmin-connect-mcp server running on stdio");

package/dist/test.js

@@ -7,7 +7,7 @@
  * Run: npm test
  */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { registerTools } from "./tools.js";
+import { registerTools, registerResources } from "./tools.js";
 import { existsSync, rmSync } from "node:fs";
 import { getSharedClient } from "./garmin-client.js";
 const TEST_FIT_DIR = "/tmp/garmin-mcp-test-fit";
@@ -16,12 +16,114 @@ async function callTool(server, name, args = {}) {
     const result = (await server._registeredTools[name].handler({ ...args }, { signal: new AbortController().signal }));
     return result;
 }
+async function callResource(server, uri) {
+    const resource = server._registeredResources[uri];
+    if (!resource)
+        throw new Error(`Resource not registered: ${uri}`);
+    const result = (await resource.readCallback(new URL(uri), {
+        signal: new AbortController().signal,
+    }));
+    return result;
+}
 function getToolText(result) {
     return result.content[0]?.text ?? "";
 }
 function getToolJson(result) {
     return JSON.parse(getToolText(result));
 }
+// ── Resource tests (no session required) ──────────────────────────────
+const resourceTests = [
+    {
+        name: "resource: workout://templates/simple-run",
+        run: async (server) => {
+            const uri = "workout://templates/simple-run";
+            const result = await callResource(server, uri);
+            if (!result.contents || result.contents.length === 0)
+                throw new Error("no contents");
+            const content = result.contents[0];
+            if (content.uri !== uri)
+                throw new Error(`wrong uri: ${content.uri}`);
+            if (content.mimeType !== "application/json")
+                throw new Error(`wrong mimeType: ${content.mimeType}`);
+            const data = JSON.parse(content.text);
+            if (!data.workoutName)
+                throw new Error("no workoutName");
+            if (!data.sportType?.sportTypeKey)
+                throw new Error("no sportTypeKey");
+            if (!Array.isArray(data.workoutSegments) ||
+                data.workoutSegments.length === 0)
+                throw new Error("no workoutSegments");
+        },
+    },
+    {
+        name: "resource: workout://templates/interval-running",
+        run: async (server) => {
+            const uri = "workout://templates/interval-running";
+            const result = await callResource(server, uri);
+            const content = result.contents[0];
+            if (content.mimeType !== "application/json")
+                throw new Error(`wrong mimeType: ${content.mimeType}`);
+            const data = JSON.parse(content.text);
+            if (data.workoutName !== "Interval Running")
+                throw new Error(`unexpected workoutName: ${data.workoutName}`);
+            // Interval running must have a RepeatGroupDTO
+            const steps = data.workoutSegments[0]?.workoutSteps ?? [];
+            const hasRepeatGroup = steps.some((s) => s.type === "RepeatGroupDTO");
+            if (!hasRepeatGroup)
+                throw new Error("missing RepeatGroupDTO");
+        },
+    },
+    {
+        name: "resource: workout://templates/tempo-run",
+        run: async (server) => {
+            const uri = "workout://templates/tempo-run";
+            const result = await callResource(server, uri);
+            const content = result.contents[0];
+            const data = JSON.parse(content.text);
+            if (data.workoutName !== "Tempo Run")
+                throw new Error(`unexpected workoutName: ${data.workoutName}`);
+            if (data.sportType.sportTypeKey !== "running")
+                throw new Error("expected running sport type");
+            const steps = data.workoutSegments[0]?.workoutSteps ?? [];
+            if (steps.length < 3)
+                throw new Error("expected at least warmup/interval/cooldown steps");
+        },
+    },
+    {
+        name: "resource: workout://templates/strength-circuit",
+        run: async (server) => {
+            const uri = "workout://templates/strength-circuit";
+            const result = await callResource(server, uri);
+            const content = result.contents[0];
+            const data = JSON.parse(content.text);
+            if (data.workoutName !== "Strength Circuit")
+                throw new Error(`unexpected workoutName: ${data.workoutName}`);
+            if (data.sportType.sportTypeKey !== "fitness_equipment")
+                throw new Error("expected fitness_equipment sport type");
+            // Must have a RepeatGroupDTO
+            const steps = data.workoutSegments[0]?.workoutSteps ?? [];
+            const hasRepeatGroup = steps.some((s) => s.type === "RepeatGroupDTO");
+            if (!hasRepeatGroup)
+                throw new Error("missing RepeatGroupDTO");
+        },
+    },
+    {
+        name: "resource: workout://reference/structure",
+        run: async (server) => {
+            const uri = "workout://reference/structure";
+            const result = await callResource(server, uri);
+            if (!result.contents || result.contents.length === 0)
+                throw new Error("no contents");
+            const content = result.contents[0];
+            if (content.uri !== uri)
+                throw new Error(`wrong uri: ${content.uri}`);
+            if (content.mimeType !== "text/markdown")
+                throw new Error(`wrong mimeType: ${content.mimeType}`);
+            if (!content.text.includes("Workout"))
+                throw new Error("reference text missing expected content");
+        },
+    },
+];
 const tests = [
     // ── Session ────────────────────────────────────────────────────────
     {
@@ -304,18 +406,188 @@ const tests = [
                 throw new Error("no zones returned");
         },
     },
+    // ── Training & Recovery ─────────────────────────────────────────
+    {
+        name: "get-training-readiness",
+        run: async (server) => {
+            const result = await callTool(server, "get-training-readiness");
+            if (result.isError)
+                throw new Error(getToolText(result));
+        },
+    },
+    {
+        name: "get-sleep-stats",
+        run: async (server) => {
+            const sevenDaysAgo = new Date(Date.now() - 7 * 86400000)
+                .toISOString()
+                .slice(0, 10);
+            const today = new Date().toISOString().slice(0, 10);
+            const result = await callTool(server, "get-sleep-stats", {
+                startDate: sevenDaysAgo,
+                endDate: today,
+            });
+            if (result.isError)
+                throw new Error(getToolText(result));
+        },
+    },
+    // ── Calendar, Goals, Badges ────────────────────────────────────────
+    {
+        name: "get-calendar",
+        run: async (server) => {
+            const result = await callTool(server, "get-calendar", {
+                year: 2026,
+                month: 2,
+            });
+            if (result.isError)
+                throw new Error(getToolText(result));
+        },
+    },
+    {
+        name: "get-goals",
+        run: async (server) => {
+            const result = await callTool(server, "get-goals", { status: "active" });
+            if (result.isError)
+                throw new Error(getToolText(result));
+        },
+    },
+    {
+        name: "get-badges",
+        run: async (server) => {
+            const result = await callTool(server, "get-badges");
+            if (result.isError)
+                throw new Error(getToolText(result));
+        },
+    },
+    {
+        name: "get-badge-leaderboard",
+        run: async (server) => {
+            const result = await callTool(server, "get-badge-leaderboard", {
+                limit: 5,
+            });
+            if (result.isError)
+                throw new Error(getToolText(result));
+        },
+    },
+    // ── Hydration & Power Zones ────────────────────────────────────────
+    {
+        name: "get-hydration",
+        run: async (server) => {
+            const result = await callTool(server, "get-hydration");
+            if (result.isError)
+                throw new Error(getToolText(result));
+        },
+    },
+    {
+        name: "get-power-zones",
+        run: async (server) => {
+            const result = await callTool(server, "get-power-zones");
+            if (result.isError)
+                throw new Error(getToolText(result));
+        },
+    },
+    // ── Workouts ───────────────────────────────────────────────────────
+    {
+        name: "list-workouts",
+        run: async (server) => {
+            const result = await callTool(server, "list-workouts", {
+                start: 0,
+                limit: 5,
+            });
+            if (result.isError)
+                throw new Error(getToolText(result));
+        },
+    },
+    {
+        name: "workout CRUD (create -> schedule -> delete)",
+        run: async (server) => {
+            // Create
+            const workout = {
+                workoutName: "MCP Test Workout (safe to delete)",
+                sportType: { sportTypeId: 1, sportTypeKey: "running" },
+                workoutSegments: [
+                    {
+                        segmentOrder: 1,
+                        sportType: { sportTypeId: 1, sportTypeKey: "running" },
+                        workoutSteps: [
+                            {
+                                type: "ExecutableStepDTO",
+                                stepOrder: 1,
+                                stepType: { stepTypeId: 3, stepTypeKey: "interval" },
+                                endCondition: {
+                                    conditionTypeId: 2,
+                                    conditionTypeKey: "time",
+                                },
+                                endConditionValue: 600,
+                                targetType: {
+                                    workoutTargetTypeId: 1,
+                                    workoutTargetTypeKey: "no.target",
+                                },
+                            },
+                        ],
+                    },
+                ],
+            };
+            const createResult = await callTool(server, "create-workout", {
+                workout: JSON.stringify(workout),
+            });
+            if (createResult.isError)
+                throw new Error(getToolText(createResult));
+            const created = getToolJson(createResult);
+            if (!created.workoutId)
+                throw new Error("no workoutId returned");
+            const wid = String(created.workoutId);
+            // Schedule to tomorrow
+            const tomorrow = new Date(Date.now() + 86400000)
+                .toISOString()
+                .slice(0, 10);
+            const schedResult = await callTool(server, "schedule-workout", {
+                workoutId: wid,
+                date: tomorrow,
+            });
+            if (schedResult.isError)
+                throw new Error(getToolText(schedResult));
+            // Delete (cleanup)
+            const delResult = await callTool(server, "delete-workout", {
+                workoutId: wid,
+            });
+            if (delResult.isError)
+                throw new Error(getToolText(delResult));
+        },
+    },
 ];
 // Resolved during bootstrap
 let activityId = "";
 async function main() {
     console.log("garmin-connect-mcp integration tests (tool-level)\n");
-    // Set up a real MCP server with all tools registered
+    // Set up a real MCP server with all tools and resources registered
     const server = new McpServer({
         name: "garmin-connect-mcp-test",
         version: "0.0.0",
     });
     registerTools(server);
-    // Bootstrap: get a recent activityId
+    registerResources(server);
+    // ── Run resource tests (no session required) ────────────────────────
+    console.log("── Resources (no session required) ──\n");
+    let passed = 0;
+    let failed = 0;
+    for (const test of resourceTests) {
+        const start = Date.now();
+        try {
+            await test.run(server);
+            const ms = Date.now() - start;
+            console.log(`  PASS  ${test.name} (${ms}ms)`);
+            passed++;
+        }
+        catch (e) {
+            const ms = Date.now() - start;
+            const msg = e instanceof Error ? e.message : String(e);
+            const short = msg.length > 120 ? msg.slice(0, 120) + "..." : msg;
+            console.log(`  FAIL  ${test.name} (${ms}ms) — ${short}`);
+            failed++;
+        }
+    }
+    // ── Bootstrap: get a recent activityId ─────────────────────────────
+    console.log("\n── Integration tests (session required) ──\n");
     console.log("Bootstrapping...");
     const listResult = await callTool(server, "list-activities", {
         limit: 1,
@@ -328,8 +600,6 @@ async function main() {
         process.exit(1);
     }
     console.log(`  activityId: ${activityId}\n`);
-    let passed = 0;
-    let failed = 0;
     for (const test of tests) {
         const start = Date.now();
         try {

package/dist/tools.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
+import { inflateRawSync } from "node:zlib";
 import { getSharedClient, sessionExists, getSessionFile, } from "./garmin-client.js";
 function jsonResult(data) {
     return {
@@ -336,6 +337,235 @@ To authenticate, you need the Playwright MCP server installed (\`@playwright/mcp
         return jsonResult(data);
     });
     // ══════════════════════════════════════════════════════════════════
+    // Training & Recovery
+    // ══════════════════════════════════════════════════════════════════
+    server.tool("get-training-readiness", "Get training readiness score for a date (based on sleep, recovery, training load)", {
+        date: z.string().optional().describe("YYYY-MM-DD, defaults to today"),
+    }, async ({ date }) => {
+        const client = getClient();
+        const d = date ?? todayDate();
+        const data = await client.get(`metrics-service/metrics/trainingreadiness/${d}`);
+        return jsonResult(data);
+    });
+    server.tool("get-sleep-stats", "Get sleep statistics over a date range (averages, trends)", {
+        startDate: z.string().describe("Start date YYYY-MM-DD"),
+        endDate: z.string().describe("End date YYYY-MM-DD"),
+    }, async ({ startDate, endDate }) => {
+        const client = getClient();
+        const data = await client.get(`sleep-service/stats/sleep/daily/${startDate}/${endDate}`);
+        return jsonResult(data);
+    });
+    // ══════════════════════════════════════════════════════════════════
+    // Calendar, Goals, Badges
+    // ══════════════════════════════════════════════════════════════════
+    server.tool("get-calendar", "Get monthly calendar with activities, workouts, and events", {
+        year: z.number().describe("Year (e.g. 2026)"),
+        month: z.number().describe("Month number 0-11 (0=January, 11=December)"),
+    }, async ({ year, month }) => {
+        const client = getClient();
+        const data = await client.get(`calendar-service/year/${year}/month/${month}`);
+        return jsonResult(data);
+    });
+    server.tool("get-goals", "Get fitness goals", {
+        status: z
+            .string()
+            .default("active")
+            .describe("Goal status: active, future, or past"),
+    }, async ({ status }) => {
+        const client = getClient();
+        const data = await client.get("goal-service/goal/goals", { status });
+        return jsonResult(data);
+    });
+    server.tool("get-badges", "Get all earned badges/achievements", {}, async () => {
+        const client = getClient();
+        const data = await client.get("badge-service/badge/earned");
+        return jsonResult(data);
+    });
+    server.tool("get-badge-leaderboard", "Get badge leaderboard among your connections", {
+        limit: z.number().default(25).describe("Max entries to return"),
+    }, async ({ limit }) => {
+        const client = getClient();
+        const data = await client.get("badge-service/badge/leaderboard", {
+            limit,
+        });
+        return jsonResult(data);
+    });
+    // ══════════════════════════════════════════════════════════════════
+    // Hydration & Power Zones
+    // ══════════════════════════════════════════════════════════════════
+    server.tool("get-hydration", "Get daily hydration/water intake data", {
+        date: z.string().optional().describe("YYYY-MM-DD, defaults to today"),
+    }, async ({ date }) => {
+        const client = getClient();
+        const d = date ?? todayDate();
+        const data = await client.get(`usersummary-service/usersummary/hydration/allData/${d}`);
+        return jsonResult(data);
+    });
+    server.tool("get-power-zones", "Get power zone configuration for all sports", {}, async () => {
+        const client = getClient();
+        const data = await client.get("biometric-service/powerZones/sports/all");
+        return jsonResult(data);
+    });
+    // ══════════════════════════════════════════════════════════════════
+    // Workouts (read + write)
+    // ══════════════════════════════════════════════════════════════════
+    server.tool("list-workouts", "List your saved workouts", {
+        start: z.number().default(0).describe("Pagination offset"),
+        limit: z.number().default(100).describe("Max workouts to return"),
+    }, async ({ start, limit }) => {
+        const client = getClient();
+        const data = await client.get("workout-service/workouts", {
+            start,
+            limit,
+        });
+        return jsonResult(data);
+    });
+    server.tool("get-workout", "Get a single workout by ID with full step/segment details", {
+        workoutId: z.string().describe("The workout ID"),
+    }, async ({ workoutId }) => {
+        const client = getClient();
+        const data = await client.get(`workout-service/workout/${workoutId}`);
+        return jsonResult(data);
+    });
+    server.tool("download-workout-fit", "Download a workout as a FIT file", {
+        workoutId: z.string().describe("The workout ID"),
+        outputDir: z
+            .string()
+            .default("./fit_files")
+            .describe("Directory to save the FIT file"),
+    }, async ({ workoutId, outputDir }) => {
+        const client = getClient();
+        const fitBytes = await client.getBytes(`workout-service/workout/FIT/${workoutId}`);
+        mkdirSync(outputDir, { recursive: true });
+        const outPath = join(outputDir, `workout_${workoutId}.fit`);
+        writeFileSync(outPath, fitBytes);
+        return textResult(`Downloaded workout FIT: ${outPath} (${fitBytes.length} bytes)`);
+    });
+    server.tool("create-workout", `Upload a workout from JSON data.
+
+Creates a new workout in Garmin Connect from structured workout data.
+
+IMPORTANT: Step types must use Garmin's DTO format:
+- Use "ExecutableStepDTO" for regular steps (warmup, interval, cooldown, recovery)
+- Use "RepeatGroupDTO" for repeat/interval groups with numberOfIterations
+
+IMPORTANT: For heart rate zone targets, use "zoneNumber" (1-5), NOT targetValueOne/targetValueTwo.
+targetValueOne/targetValueTwo are only for absolute value ranges (e.g. pace in m/s, power in watts).
+
+Sport type IDs: 1=running, 2=cycling, 3=swimming, 4=walking, 5=multi, 6=fitness, 7=hiking.
+Step type IDs: warmup (1), cooldown (2), interval (3), recovery (4), rest (5).
+End condition IDs: distance (1, value in meters), time (2, value in seconds), open (7, no value needed).
+Target type IDs: no.target (1), speed (2, m/s range via targetValueOne/targetValueTwo), heart.rate.zone (4, use zoneNumber 1-5), power.zone (11, use zoneNumber).
+
+**Available Templates:**
+Instead of building workout JSON from scratch, use these MCP resources as starting points:
+- workout://templates/simple-run - Basic warmup/run/cooldown structure
+- workout://templates/interval-running - Interval training with repeat groups
+- workout://templates/tempo-run - Tempo run with heart rate zone targets
+- workout://templates/strength-circuit - Strength training circuit structure
+- workout://reference/structure - Complete JSON structure reference with all fields
+
+Access these resources using your MCP client's resource reading capability, modify the template
+as needed, and pass the resulting JSON as the workout parameter.
+
+Example workout structure with HR zone target:
+{
+  "workoutName": "My Workout",
+  "sportType": {"sportTypeId": 1, "sportTypeKey": "running"},
+  "workoutSegments": [{
+    "segmentOrder": 1,
+    "sportType": {"sportTypeId": 1, "sportTypeKey": "running"},
+    "workoutSteps": [{
+      "type": "ExecutableStepDTO",
+      "stepOrder": 1,
+      "stepType": {"stepTypeId": 3, "stepTypeKey": "interval"},
+      "endCondition": {"conditionTypeId": 2, "conditionTypeKey": "time"},
+      "endConditionValue": 1200.0,
+      "targetType": {"workoutTargetTypeId": 4, "workoutTargetTypeKey": "heart.rate.zone"},
+      "zoneNumber": 3
+    }]
+  }]
+}
+
+Example with RepeatGroupDTO for intervals:
+{
+  "workoutName": "Interval Run",
+  "sportType": {"sportTypeId": 1, "sportTypeKey": "running"},
+  "workoutSegments": [{
+    "segmentOrder": 1,
+    "sportType": {"sportTypeId": 1, "sportTypeKey": "running"},
+    "workoutSteps": [
+      {
+        "type": "ExecutableStepDTO",
+        "stepOrder": 1,
+        "stepType": {"stepTypeId": 1, "stepTypeKey": "warmup"},
+        "endCondition": {"conditionTypeId": 2, "conditionTypeKey": "time"},
+        "endConditionValue": 600.0,
+        "targetType": {"workoutTargetTypeId": 1, "workoutTargetTypeKey": "no.target"}
+      },
+      {
+        "type": "RepeatGroupDTO",
+        "stepOrder": 2,
+        "numberOfIterations": 6,
+        "workoutSteps": [
+          {
+            "type": "ExecutableStepDTO",
+            "stepOrder": 1,
+            "stepType": {"stepTypeId": 3, "stepTypeKey": "interval"},
+            "endCondition": {"conditionTypeId": 2, "conditionTypeKey": "time"},
+            "endConditionValue": 60.0,
+            "targetType": {"workoutTargetTypeId": 4, "workoutTargetTypeKey": "heart.rate.zone"},
+            "zoneNumber": 5
+          },
+          {
+            "type": "ExecutableStepDTO",
+            "stepOrder": 2,
+            "stepType": {"stepTypeId": 4, "stepTypeKey": "recovery"},
+            "endCondition": {"conditionTypeId": 2, "conditionTypeKey": "time"},
+            "endConditionValue": 90.0,
+            "targetType": {"workoutTargetTypeId": 4, "workoutTargetTypeKey": "heart.rate.zone"},
+            "zoneNumber": 2
+          }
+        ]
+      },
+      {
+        "type": "ExecutableStepDTO",
+        "stepOrder": 3,
+        "stepType": {"stepTypeId": 2, "stepTypeKey": "cooldown"},
+        "endCondition": {"conditionTypeId": 2, "conditionTypeKey": "time"},
+        "endConditionValue": 600.0,
+        "targetType": {"workoutTargetTypeId": 1, "workoutTargetTypeKey": "no.target"}
+      }
+    ]
+  }]
+}`, {
+        workout: z
+            .string()
+            .describe("JSON string of the workout object to create"),
+    }, async ({ workout }) => {
+        const client = getClient();
+        const workoutObj = JSON.parse(workout);
+        const data = await client.post("workout-service/workout", workoutObj);
+        return jsonResult(data);
+    });
+    server.tool("schedule-workout", "Schedule an existing workout to a date on your calendar. The workout will sync to your device.", {
+        workoutId: z.string().describe("The workout ID"),
+        date: z.string().describe("Date to schedule YYYY-MM-DD"),
+    }, async ({ workoutId, date }) => {
+        const client = getClient();
+        const data = await client.post(`workout-service/schedule/${workoutId}`, {
+            date,
+        });
+        return jsonResult(data);
+    });
+    server.tool("delete-workout", "Delete a workout from Garmin Connect", {
+        workoutId: z.string().describe("The workout ID to delete"),
+    }, async ({ workoutId }) => {
+        const client = getClient();
+        await client.delete(`workout-service/workout/${workoutId}`);
+        return textResult(`Workout ${workoutId} deleted`);
+    });
+    // ══════════════════════════════════════════════════════════════════
     // Testing
     // ══════════════════════════════════════════════════════════════════
     server.tool("run-tests", "Returns a test plan for verifying all garmin-connect-mcp tools work. Call each tool listed and report results.", {}, async () => {
@@ -396,7 +626,307 @@ Present results as a markdown table: | Tool | Status | Notes |
 Count total passed vs failed at the end.`);
     });
 }
-import { inflateRawSync } from "node:zlib";
+// ── Workout Templates (MCP Resources) ──────────────────────────────────────
+// Templates adapted from Taxuspt/garmin_mcp (MIT License, Copyright (c) 2025 Alexandre Domingues)
+// https://github.com/Taxuspt/garmin_mcp/blob/main/src/garmin_mcp/workout_templates.py
+const WORKOUT_TEMPLATES = {
+    "simple-run": {
+        workoutName: "Simple Run",
+        sportType: { sportTypeId: 1, sportTypeKey: "running" },
+        workoutSegments: [
+            {
+                segmentOrder: 1,
+                sportType: { sportTypeId: 1, sportTypeKey: "running" },
+                workoutSteps: [
+                    {
+                        type: "ExecutableStepDTO",
+                        stepOrder: 1,
+                        stepType: { stepTypeId: 1, stepTypeKey: "warmup" },
+                        endCondition: { conditionTypeId: 2, conditionTypeKey: "time" },
+                        endConditionValue: 300.0,
+                        targetType: {
+                            workoutTargetTypeId: 1,
+                            workoutTargetTypeKey: "no.target",
+                        },
+                    },
+                    {
+                        type: "ExecutableStepDTO",
+                        stepOrder: 2,
+                        stepType: { stepTypeId: 3, stepTypeKey: "interval" },
+                        endCondition: { conditionTypeId: 2, conditionTypeKey: "time" },
+                        endConditionValue: 1800.0,
+                        targetType: {
+                            workoutTargetTypeId: 1,
+                            workoutTargetTypeKey: "no.target",
+                        },
+                    },
+                    {
+                        type: "ExecutableStepDTO",
+                        stepOrder: 3,
+                        stepType: { stepTypeId: 2, stepTypeKey: "cooldown" },
+                        endCondition: { conditionTypeId: 2, conditionTypeKey: "time" },
+                        endConditionValue: 300.0,
+                        targetType: {
+                            workoutTargetTypeId: 1,
+                            workoutTargetTypeKey: "no.target",
+                        },
+                    },
+                ],
+            },
+        ],
+    },
+    "interval-running": {
+        workoutName: "Interval Running",
+        sportType: { sportTypeId: 1, sportTypeKey: "running" },
+        workoutSegments: [
+            {
+                segmentOrder: 1,
+                sportType: { sportTypeId: 1, sportTypeKey: "running" },
+                workoutSteps: [
+                    {
+                        type: "ExecutableStepDTO",
+                        stepOrder: 1,
+                        stepType: { stepTypeId: 1, stepTypeKey: "warmup" },
+                        endCondition: { conditionTypeId: 2, conditionTypeKey: "time" },
+                        endConditionValue: 600.0,
+                        targetType: {
+                            workoutTargetTypeId: 1,
+                            workoutTargetTypeKey: "no.target",
+                        },
+                    },
+                    {
+                        type: "RepeatGroupDTO",
+                        stepOrder: 2,
+                        numberOfIterations: 6,
+                        workoutSteps: [
+                            {
+                                type: "ExecutableStepDTO",
+                                stepOrder: 1,
+                                stepType: { stepTypeId: 3, stepTypeKey: "interval" },
+                                endCondition: { conditionTypeId: 2, conditionTypeKey: "time" },
+                                endConditionValue: 60.0,
+                                targetType: {
+                                    workoutTargetTypeId: 4,
+                                    workoutTargetTypeKey: "heart.rate.zone",
+                                },
+                                zoneNumber: 5,
+                            },
+                            {
+                                type: "ExecutableStepDTO",
+                                stepOrder: 2,
+                                stepType: { stepTypeId: 4, stepTypeKey: "recovery" },
+                                endCondition: { conditionTypeId: 2, conditionTypeKey: "time" },
+                                endConditionValue: 90.0,
+                                targetType: {
+                                    workoutTargetTypeId: 4,
+                                    workoutTargetTypeKey: "heart.rate.zone",
+                                },
+                                zoneNumber: 2,
+                            },
+                        ],
+                    },
+                    {
+                        type: "ExecutableStepDTO",
+                        stepOrder: 3,
+                        stepType: { stepTypeId: 2, stepTypeKey: "cooldown" },
+                        endCondition: { conditionTypeId: 2, conditionTypeKey: "time" },
+                        endConditionValue: 600.0,
+                        targetType: {
+                            workoutTargetTypeId: 1,
+                            workoutTargetTypeKey: "no.target",
+                        },
+                    },
+                ],
+            },
+        ],
+    },
+    "tempo-run": {
+        workoutName: "Tempo Run",
+        sportType: { sportTypeId: 1, sportTypeKey: "running" },
+        workoutSegments: [
+            {
+                segmentOrder: 1,
+                sportType: { sportTypeId: 1, sportTypeKey: "running" },
+                workoutSteps: [
+                    {
+                        type: "ExecutableStepDTO",
+                        stepOrder: 1,
+                        stepType: { stepTypeId: 1, stepTypeKey: "warmup" },
+                        endCondition: { conditionTypeId: 2, conditionTypeKey: "time" },
+                        endConditionValue: 600.0,
+                        targetType: {
+                            workoutTargetTypeId: 4,
+                            workoutTargetTypeKey: "heart.rate.zone",
+                        },
+                        zoneNumber: 2,
+                    },
+                    {
+                        type: "ExecutableStepDTO",
+                        stepOrder: 2,
+                        stepType: { stepTypeId: 3, stepTypeKey: "interval" },
+                        endCondition: { conditionTypeId: 2, conditionTypeKey: "time" },
+                        endConditionValue: 1200.0,
+                        targetType: {
+                            workoutTargetTypeId: 4,
+                            workoutTargetTypeKey: "heart.rate.zone",
+                        },
+                        zoneNumber: 4,
+                    },
+                    {
+                        type: "ExecutableStepDTO",
+                        stepOrder: 3,
+                        stepType: { stepTypeId: 2, stepTypeKey: "cooldown" },
+                        endCondition: { conditionTypeId: 2, conditionTypeKey: "time" },
+                        endConditionValue: 600.0,
+                        targetType: {
+                            workoutTargetTypeId: 4,
+                            workoutTargetTypeKey: "heart.rate.zone",
+                        },
+                        zoneNumber: 2,
+                    },
+                ],
+            },
+        ],
+    },
+    "strength-circuit": {
+        workoutName: "Strength Circuit",
+        sportType: { sportTypeId: 6, sportTypeKey: "fitness_equipment" },
+        workoutSegments: [
+            {
+                segmentOrder: 1,
+                sportType: { sportTypeId: 6, sportTypeKey: "fitness_equipment" },
+                workoutSteps: [
+                    {
+                        type: "ExecutableStepDTO",
+                        stepOrder: 1,
+                        stepType: { stepTypeId: 1, stepTypeKey: "warmup" },
+                        endCondition: { conditionTypeId: 2, conditionTypeKey: "time" },
+                        endConditionValue: 300.0,
+                        targetType: {
+                            workoutTargetTypeId: 1,
+                            workoutTargetTypeKey: "no.target",
+                        },
+                    },
+                    {
+                        type: "RepeatGroupDTO",
+                        stepOrder: 2,
+                        numberOfIterations: 3,
+                        workoutSteps: [
+                            {
+                                type: "ExecutableStepDTO",
+                                stepOrder: 1,
+                                stepType: { stepTypeId: 3, stepTypeKey: "interval" },
+                                endCondition: { conditionTypeId: 2, conditionTypeKey: "time" },
+                                endConditionValue: 40.0,
+                                targetType: {
+                                    workoutTargetTypeId: 1,
+                                    workoutTargetTypeKey: "no.target",
+                                },
+                                description: "Exercise (e.g. push-ups, squats, rows)",
+                            },
+                            {
+                                type: "ExecutableStepDTO",
+                                stepOrder: 2,
+                                stepType: { stepTypeId: 5, stepTypeKey: "rest" },
+                                endCondition: { conditionTypeId: 2, conditionTypeKey: "time" },
+                                endConditionValue: 20.0,
+                                targetType: {
+                                    workoutTargetTypeId: 1,
+                                    workoutTargetTypeKey: "no.target",
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        type: "ExecutableStepDTO",
+                        stepOrder: 3,
+                        stepType: { stepTypeId: 2, stepTypeKey: "cooldown" },
+                        endCondition: { conditionTypeId: 2, conditionTypeKey: "time" },
+                        endConditionValue: 300.0,
+                        targetType: {
+                            workoutTargetTypeId: 1,
+                            workoutTargetTypeKey: "no.target",
+                        },
+                    },
+                ],
+            },
+        ],
+    },
+};
+const WORKOUT_STRUCTURE_REFERENCE = `# Garmin Connect Workout JSON Structure Reference
+
+## Top-level fields
+- workoutName: string (required)
+- sportType: { sportTypeId: number, sportTypeKey: string } (required)
+  - IDs: 1=running, 2=cycling, 3=swimming, 4=walking, 5=multi, 6=fitness_equipment, 7=hiking
+- workoutSegments: array of segment objects (required)
+- description: string (optional)
+
+## Segment fields
+- segmentOrder: number (1-based, required)
+- sportType: same as top-level (required)
+- workoutSteps: array of step objects (required)
+
+## Step types
+
+### ExecutableStepDTO (regular steps)
+- type: "ExecutableStepDTO" (required)
+- stepOrder: number (1-based within the containing steps array)
+- stepType: { stepTypeId: number, stepTypeKey: string }
+  - 1="warmup", 2="cooldown", 3="interval", 4="recovery", 5="rest"
+- endCondition: { conditionTypeId: number, conditionTypeKey: string }
+  - 1="distance" (endConditionValue in meters)
+  - 2="time" (endConditionValue in seconds)
+  - 7="lap.button" (press lap button; no endConditionValue needed)
+- endConditionValue: number (required for distance/time conditions)
+- targetType: { workoutTargetTypeId: number, workoutTargetTypeKey: string }
+  - 1="no.target"
+  - 2="speed" — use targetValueOne/targetValueTwo (m/s)
+  - 4="heart.rate.zone" — use zoneNumber (1-5), NOT targetValueOne/targetValueTwo
+  - 6="cadence" — use targetValueOne/targetValueTwo (steps per minute)
+  - 11="power.zone" — use zoneNumber
+- zoneNumber: number 1-5 (for heart.rate.zone or power.zone targets only)
+- targetValueOne: number (lower bound for speed/cadence ranges)
+- targetValueTwo: number (upper bound for speed/cadence ranges)
+- description: string (optional, displayed on device)
+
+### RepeatGroupDTO (repeat blocks)
+- type: "RepeatGroupDTO" (required)
+- stepOrder: number (1-based within the containing steps array)
+- numberOfIterations: number (how many times to repeat)
+- workoutSteps: array of ExecutableStepDTO (the steps to repeat)
+  - stepOrder within this array is 1-based and independent of the parent
+
+## Notes
+- NEVER use targetValueOne/targetValueTwo for heart rate zones — use zoneNumber instead.
+  Using targetValueOne/targetValueTwo with heart.rate.zone target type causes Garmin to
+  misinterpret the values as pace (m/s), resulting in impossible paces like ~11 sec/mile.
+- RepeatGroupDTO cannot be nested inside another RepeatGroupDTO.
+- All stepOrder values within the same array must be sequential starting from 1.
+`;
+export function registerResources(server) {
+    for (const [name, template] of Object.entries(WORKOUT_TEMPLATES)) {
+        const uri = `workout://templates/${name}`;
+        server.resource(name, uri, async (resourceUri) => ({
+            contents: [
+                {
+                    uri: resourceUri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(template, null, 2),
+                },
+            ],
+        }));
+    }
+    server.resource("workout-structure-reference", "workout://reference/structure", async (resourceUri) => ({
+        contents: [
+            {
+                uri: resourceUri.href,
+                mimeType: "text/markdown",
+                text: WORKOUT_STRUCTURE_REFERENCE,
+            },
+        ],
+    }));
+}
 /**
  * Minimal zip extraction — finds the first .fit file using the central
  * directory (which always has correct sizes, unlike local headers that

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etweisberg/garmin-connect-mcp",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "MCP server for Garmin Connect — access activities, metrics, and FIT files via Claude Code",
   "type": "module",
   "bin": {