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.

Author: yerzhansa

src/agent/core.ts

@@ -58,8 +58,11 @@ export class CyclingCoachAgent {
           athleteId: config.intervals.athleteId,
         })
       : null;
+    const intervalsAuth = config.intervals.apiKey
+      ? { apiKey: config.intervals.apiKey, athleteId: config.intervals.athleteId }
+      : null;
 
-    this.tools = createTools(this.memory, intervals);
+    this.tools = createTools(this.memory, intervals, intervalsAuth);
     this.systemPrompt = buildSystemPrompt(this.memory);
   }
 

src/agent/tools.ts

@@ -42,7 +42,11 @@ export function createMemoryReadTool(memory: Memory) {
 // TOOL BUILDER
 // ============================================================================
 
-export function createTools(memory: Memory, intervals: IntervalsClient | null) {
+export function createTools(
+  memory: Memory,
+  intervals: IntervalsClient | null,
+  intervalsAuth: { apiKey: string; athleteId: string } | null,
+) {
   return {
     // ── Cycling logic tools (local, no API) ─────────────────────────────
 
@@ -207,15 +211,18 @@ export function createTools(memory: Memory, intervals: IntervalsClient | null) {
 
     // ── Intervals.icu tools ─────────────────────────────────────────────
 
-    ...(intervals ? createIntervalsTools(intervals) : {}),
+    ...(intervals && intervalsAuth ? createIntervalsTools(intervals, intervalsAuth) : {}),
   };
 }
 
 // ============================================================================
 // INTERVALS.ICU TOOLS
 // ============================================================================
 
-function createIntervalsTools(client: IntervalsClient) {
+function createIntervalsTools(
+  client: IntervalsClient,
+  auth: { apiKey: string; athleteId: string },
+) {
   return {
     intervals_fetch_athlete: tool({
       description:
@@ -303,5 +310,56 @@ 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;
+      },
+    }),
+
+    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 server will reject the delete.",
+      inputSchema: zodSchema(
+        z.object({
+          eventId: z.number().int().describe("Event ID from intervals_list_events"),
+        }),
+      ),
+      execute: async (input: { eventId: number }) => {
+        const today = new Date().toISOString().split("T")[0];
+        const url =
+          `https://intervals.icu/api/v1/athlete/${auth.athleteId}` +
+          `/events/${input.eventId}?notBefore=${today}`;
+        const basic = Buffer.from(`API_KEY:${auth.apiKey}`).toString("base64");
+        const res = await fetch(url, {
+          method: "DELETE",
+          headers: { Authorization: `Basic ${basic}` },
+        });
+        if (!res.ok) {
+          const body = await res.text().catch(() => "");
+          return { error: `http_${res.status}`, message: body || res.statusText };
+        }
+        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,52 @@ 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 (filters created workouts
+    // by optional oldest/newest query params; ignores category since we only emit WORKOUT)
+    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);
+    }),
+
+    // DELETE /api/v1/athlete/:id/events/:eventId — delete scheduled event; honors
+    // ?notBefore=YYYY-MM-DD by rejecting when the event's date is earlier.
+    http.delete(
+      "https://intervals.icu/api/v1/athlete/:id/events/:eventId",
+      ({ request, params }) => {
+        const eventId = Number(params.eventId);
+        const url = new URL(request.url);
+        const notBefore = url.searchParams.get("notBefore");
+
+        const idx = createdWorkouts.findIndex((w) => w.id === eventId);
+        if (idx === -1) {
+          return HttpResponse.json({ error: "not_found" }, { status: 404 });
+        }
+        const workout = createdWorkouts[idx];
+        if (notBefore && workout.start_date_local.slice(0, 10) < notBefore) {
+          return HttpResponse.json(
+            { error: "event is before notBefore" },
+            { status: 400 },
+          );
+        }
+        createdWorkouts.splice(idx, 1);
+        deletedEventIds.push(eventId);
+        return new HttpResponse(null, { status: 200 });
+      },
+    ),
   ];
 
   const server = setupServer(...handlers);
 
-  return { server, createdWorkouts };
+  return { server, createdWorkouts, deletedEventIds };
 }