feat(tools): add list/delete workout tools for intervals.icu (#40)

* feat(tools): add list/delete workout tools for intervals.icu

Let the athlete remove scheduled workouts they no longer want. Agent
calls intervals_list_events first, shows the list, and asks which to
delete. intervals_delete_workout uses ?notBefore=today so the server
protects history — past workouts cannot be deleted.

* refactor(tools): slim intervals_list_events payload, align error shape

Project events to {id, start_date_local, name, moving_time,
icu_training_load} so the LLM sees identifiable workouts without
workout_doc and other bloat. Rename delete error field message ->
details to match the convention in intervals_create_workout.

* fix(tools): enforce past-workout protection client-side

The intervals.icu ?notBefore query param only caps the ?others=true
cascade — it does not protect the target of a single-event DELETE.
Direct API probes confirmed past-dated events get deleted regardless
of the notBefore value.

Switch to a client-side guard: events.get() → compare startDateLocal
against today → refuse with past_workout_protected before calling
delete. Also fix a runtime mismatch where the library types are
snake_case but the runtime runs camelCaseKeys on every parsed response
(so fetched.value.start_date_local was always undefined). Add a local
IntervalsEventRuntime type reflecting the real shape.

Drop the now-unnecessary intervalsAuth plumbing (no more raw fetch).

Mock updates: add GET /events/:id (needed by the new guard) and
remove the pretend notBefore enforcement from DELETE so the mock
matches real server behavior.

Author: yerzhansa

src/agent/tools.ts

@@ -215,6 +215,17 @@ export function createTools(memory: Memory, intervals: IntervalsClient | null) {
 // INTERVALS.ICU TOOLS
 // ============================================================================
 
+// intervals-icu-api's TypeScript types declare snake_case fields, but the runtime
+// runs `camelCaseKeys` over every parsed response. So the types lie: at runtime we
+// see `startDateLocal`, not `start_date_local`. This local type reflects reality.
+type IntervalsEventRuntime = {
+  id: number;
+  startDateLocal: string;
+  name?: string | null;
+  movingTime?: number | null;
+  icuTrainingLoad?: number | null;
+};
+
 function createIntervalsTools(client: IntervalsClient) {
   return {
     intervals_fetch_athlete: tool({
@@ -303,5 +314,62 @@ function createIntervalsTools(client: IntervalsClient) {
         return { created: true, event: result.value };
       },
     }),
+
+    intervals_list_events: tool({
+      description:
+        "List scheduled calendar workouts on intervals.icu for a date range. " +
+        "Use this BEFORE deleting so you can show the athlete the list (id, date, name) " +
+        "and ask which one to delete. Filters to WORKOUT category only.",
+      inputSchema: zodSchema(
+        z.object({
+          oldest: z.string().describe("Oldest date (YYYY-MM-DD)"),
+          newest: z.string().optional().describe("Newest date (YYYY-MM-DD)"),
+        }),
+      ),
+      execute: async (input: { oldest: string; newest?: string }) => {
+        const result = await client.events.list({
+          oldest: input.oldest,
+          newest: input.newest ?? undefined,
+          category: ["WORKOUT"],
+        });
+        if (!result.ok) return { error: result.error.kind };
+        return (result.value as unknown as IntervalsEventRuntime[]).map((e) => ({
+          id: e.id,
+          startDateLocal: e.startDateLocal,
+          name: e.name,
+          movingTime: e.movingTime,
+          icuTrainingLoad: e.icuTrainingLoad,
+        }));
+      },
+    }),
+
+    intervals_delete_workout: tool({
+      description:
+        "Delete a scheduled workout from the intervals.icu calendar by event ID. " +
+        "ALWAYS call intervals_list_events first, show the athlete the list, and " +
+        "confirm which workout to delete before calling this. Past workouts (before " +
+        "today) are protected — the tool refuses without calling the server.",
+      inputSchema: zodSchema(
+        z.object({
+          eventId: z.number().int().describe("Event ID from intervals_list_events"),
+        }),
+      ),
+      execute: async (input: { eventId: number }) => {
+        const fetched = await client.events.get(input.eventId);
+        if (!fetched.ok) return { error: fetched.error.kind };
+        const event = fetched.value as unknown as IntervalsEventRuntime;
+        const today = new Date().toISOString().split("T")[0];
+        const eventDate = event.startDateLocal.slice(0, 10);
+        if (eventDate < today) {
+          return {
+            error: "past_workout_protected",
+            details: `Cannot delete workout dated ${eventDate} — it's before today (${today}).`,
+          };
+        }
+        const result = await client.events.delete(input.eventId);
+        if (!result.ok) return { error: result.error.kind };
+        return { deleted: true };
+      },
+    }),
   };
 }

tests/helpers/mock-intervals.ts

@@ -6,11 +6,12 @@
  * a mutable array of every workout POSTed via the events endpoint.
  *
  * Usage:
- *   const { server, createdWorkouts } = createMockIntervalsServer();
+ *   const { server, createdWorkouts, deletedEventIds } = createMockIntervalsServer();
  *   server.listen({ onUnhandledRequest: "bypass" });
  *   // ... run agent ...
  *   server.close();
  *   console.log(createdWorkouts); // inspect created workouts
+ *   console.log(deletedEventIds); // inspect deleted event IDs
  */
 
 import { http, HttpResponse } from "msw";
@@ -294,6 +295,7 @@ export function createMockIntervalsServer(options: MockIntervalsOptions = {}) {
   const activities = defaultActivities(options.activities);
   const wellness = defaultWellness(options.wellness);
   const createdWorkouts: CreatedWorkout[] = [];
+  const deletedEventIds: number[] = [];
   let nextEventId = 5000;
 
   const handlers = [
@@ -352,9 +354,56 @@ export function createMockIntervalsServer(options: MockIntervalsOptions = {}) {
       createdWorkouts.push(workout);
       return HttpResponse.json({ id: eventId, ...body }, { status: 200 });
     }),
+
+    // GET /api/v1/athlete/:id/events — list scheduled events
+    http.get("https://intervals.icu/api/v1/athlete/:id/events", ({ request }) => {
+      const url = new URL(request.url);
+      const oldest = url.searchParams.get("oldest");
+      const newest = url.searchParams.get("newest");
+
+      let filtered = createdWorkouts;
+      if (oldest) {
+        filtered = filtered.filter((w) => w.start_date_local >= oldest);
+      }
+      if (newest) {
+        filtered = filtered.filter((w) => w.start_date_local <= newest + "T23:59:59");
+      }
+      return HttpResponse.json(filtered);
+    }),
+
+    // GET /api/v1/athlete/:id/events/:eventId — fetch single event (used by the
+    // delete tool to read the authoritative date before deciding whether to delete)
+    http.get(
+      "https://intervals.icu/api/v1/athlete/:id/events/:eventId",
+      ({ params }) => {
+        const eventId = Number(params.eventId);
+        const workout = createdWorkouts.find((w) => w.id === eventId);
+        if (!workout) {
+          return HttpResponse.json({ error: "not_found" }, { status: 404 });
+        }
+        return HttpResponse.json(workout);
+      },
+    ),
+
+    // DELETE /api/v1/athlete/:id/events/:eventId — delete scheduled event
+    // (no notBefore enforcement — the real API's notBefore only caps the `others`
+    // cascade, not the target event, so protection lives client-side in the tool)
+    http.delete(
+      "https://intervals.icu/api/v1/athlete/:id/events/:eventId",
+      ({ params }) => {
+        const eventId = Number(params.eventId);
+        const idx = createdWorkouts.findIndex((w) => w.id === eventId);
+        if (idx === -1) {
+          return HttpResponse.json({ error: "not_found" }, { status: 404 });
+        }
+        createdWorkouts.splice(idx, 1);
+        deletedEventIds.push(eventId);
+        return new HttpResponse(null, { status: 200 });
+      },
+    ),
   ];
 
   const server = setupServer(...handlers);
 
-  return { server, createdWorkouts };
+  return { server, createdWorkouts, deletedEventIds };
 }