@trainheroic-unofficial/athlete-mcp 1.5.0 → 1.6.0

package/dist/server.mjs

@@ -214,6 +214,16 @@ const logSessionArgsSchema = z.object({
 	})).min(1)
 });
 logSessionArgsSchema.extend({ athleteId: idArgSchema });
+/**
+* Args for removing a personal (athlete-created) workout session. `programWorkoutId` is the
+* range item's top-level `id`; `date` is that session's day, used to look the item back up so the
+* write can confirm it is a personal session (`personal_cal === true`) before deleting. A
+* coach-scheduled workout is never removed this way.
+*/
+const athleteSessionRemoveArgsSchema = z.object({
+	programWorkoutId: idArgSchema,
+	date: dateString
+});
 z.looseObject({
 	title: z.string().min(1),
 	param_1_type: z.number().optional(),
@@ -661,6 +671,22 @@ function str(v) {
 	return typeof v === "string" && v !== "" ? v : null;
 }
 /**
+* The display title of a saved-copy exercise row, preferring `exercise_title`, then `title`, then
+* the given fallback. The saved-workout shape carries the title under either key depending on the
+* endpoint, so this is the one place that reconciles them.
+*/
+function exerciseTitle(ex, fallback = "") {
+	return typeof ex.exercise_title === "string" && ex.exercise_title || typeof ex.title === "string" && ex.title || fallback;
+}
+/**
+* True when a program-workout range item is a personal (athlete-created) session rather than a
+* coach-scheduled one. The API marks these with `personal_cal === true`; this is the single
+* definition every consumer (presenter, find-or-create, the remove guard) reads through.
+*/
+function isPersonalSession(pw) {
+	return isRecord(pw) && pw.personal_cal === true;
+}
+/**
 * Rank candidate rows for a free-text query (FTS5 replacement). Higher is better:
 * exact title, then prefix, then count of matched tokens, with shorter titles and
 * standard (non-custom) exercises preferred on ties.
@@ -900,6 +926,7 @@ function presentAthleteWorkout(raw) {
 		team: str(rec.team_title),
 		instruction: str(workout.instruction),
 		logged: blocks.some((b) => b.exercises.some((e) => e.performed.length > 0)),
+		personal: isPersonalSession(rec),
 		blocks
 	};
 }
@@ -907,6 +934,81 @@ function presentAthleteWorkouts(list) {
 	return list.map(presentAthleteWorkout);
 }
 /**
+* Narrow a coach-athlete workout range to a single program or team. The range endpoint returns
+* every program the athlete is enrolled in on a date; for a high-enrollment athlete that is many
+* workouts, so a caller wanting one program's session narrows it here. Match by `programId`/`teamId`
+* (exact, on the raw `program_id`/`team_id`) or by `programTitle` (case-insensitive substring on the
+* `program_title`/`team_title`) — the title match lets a caller target a program by name without
+* first resolving its id. Any one match keeps the workout; with no filter the list is unchanged.
+*/
+function selectWorkoutsByProgram(list, filter) {
+	const { programId, teamId, programTitle } = filter;
+	const needle = programTitle?.trim().toLowerCase();
+	if (programId === void 0 && teamId === void 0 && !needle) return [...list];
+	return list.filter((pw) => {
+		const rec = pw;
+		if (programId !== void 0 && coerceInt(rec.program_id) === programId) return true;
+		if (teamId !== void 0 && coerceInt(rec.team_id) === teamId) return true;
+		if (needle) {
+			if (`${str(rec.program_title) ?? ""} ${str(rec.team_title) ?? ""}`.toLowerCase().includes(needle)) return true;
+		}
+		return false;
+	});
+}
+/**
+* Project a workout range to just the ids a set-log write needs, read from the SAME saved-copy
+* location {@link findSavedWorkoutSet} matches against (`summarizedSavedWorkout.saved_workout`).
+* This is the self-service path for logging: instead of grepping the multi-KB `--raw` blob for
+* which of several id fields maps to `--set`, callers read `savedWorkoutSetId` and each
+* `savedWorkoutSetExerciseId` straight off these rows. Each target also carries its program/team
+* so a caller can pick the right session when the athlete is on several. One row per saved set,
+* dropping any set with no resolvable id.
+*/
+function presentLogTargets(list) {
+	const targets = [];
+	for (const pw of list) {
+		const rec = pw;
+		const ssw = isRecord(rec.summarizedSavedWorkout) ? rec.summarizedSavedWorkout : {};
+		const saved = isRecord(ssw.saved_workout) ? ssw.saved_workout : null;
+		if (!saved) continue;
+		const date = str(rec.date) ?? "";
+		const workoutTitle = str(rec.workout_title) ?? "";
+		const program = str(rec.program_title);
+		const programId = coerceInt(rec.program_id);
+		const team = str(rec.team_title);
+		const teamId = coerceInt(rec.team_id);
+		const sets = Array.isArray(saved.workoutSets) ? saved.workoutSets : [];
+		for (const s of sets) {
+			if (!isRecord(s)) continue;
+			const savedWorkoutSetId = coerceInt(s.id);
+			if (savedWorkoutSetId === null) continue;
+			const exercises = (Array.isArray(s.workoutSetExercises) ? s.workoutSetExercises : []).filter(isRecord).map((ex) => {
+				const id = coerceInt(ex.id);
+				if (id === null) return null;
+				return {
+					savedWorkoutSetExerciseId: id,
+					title: exerciseTitle(ex),
+					units: exerciseUnits(ex.param_1_type, ex.param_2_type),
+					prescribed: prescribedSets(ex),
+					performed: performedSets(ex)
+				};
+			}).filter((e) => e !== null);
+			targets.push({
+				date,
+				workoutTitle,
+				program,
+				programId,
+				team,
+				teamId,
+				savedWorkoutSetId,
+				setTitle: str(s.title),
+				exercises
+			});
+		}
+	}
+	return targets;
+}
+/**
 * Narrow a presented workout list for the common "what did I actually do" reads. `loggedOnly`
 * keeps only workouts the athlete logged a set on (the reliable signal, not the API's
 * completion flag). `limit` keeps the most recent N by date (newest first). Both are pure
@@ -934,6 +1036,7 @@ function summarizeAthleteWorkouts(list) {
 			program: w.program,
 			team: w.team,
 			logged: w.logged,
+			personal: w.personal,
 			exerciseCount,
 			performedCount
 		};
@@ -1112,8 +1215,7 @@ function findSavedWorkoutSet(workouts, savedWorkoutSetId) {
 			if (setId !== null) {
 				const exLabels = exercises.map((ex) => {
 					const exId = coerceInt(ex.id);
-					const title = typeof ex.exercise_title === "string" && ex.exercise_title || typeof ex.title === "string" && ex.title || "exercise";
-					return exId === null ? null : `${exId} (${title})`;
+					return exId === null ? null : `${exId} (${exerciseTitle(ex, "exercise")})`;
 				}).filter((x) => x !== null);
 				available.push(`set ${setId} → exercise ids: ${exLabels.join(", ") || "none"}`);
 			}
@@ -1228,8 +1330,7 @@ async function writeSetResults(client, target, workouts, savedWorkoutSetId, resu
 		if (!ex) {
 			const valid = exercises.map((e) => {
 				const id = coerceInt(e.id);
-				const title = typeof e.exercise_title === "string" && e.exercise_title || typeof e.title === "string" && e.title || "exercise";
-				return id === null ? null : `${id} (${title})`;
+				return id === null ? null : `${id} (${exerciseTitle(e, "exercise")})`;
 			}).filter((x) => x !== null);
 			throw new Error(`savedWorkoutSetExerciseId ${result.savedWorkoutSetExerciseId} not found in saved workout set ${savedWorkoutSetId}. Exercises in this set: ${valid.join(", ") || "none"}.`);
 		}
@@ -1304,17 +1405,30 @@ async function addExercisesToWorkout(client, workoutId, exercises) {
 	return res.data;
 }
 /**
+* DELETE /v5/programWorkouts/{programWorkoutId} — remove a personal (athlete-created) workout
+* session from the athlete's own calendar. Re-reads the day and removes ONLY a personal session
+* (`personal_cal`): it throws if no workout with that id is on the date, or if the target is a
+* coach-scheduled workout (which is not the athlete's to delete). This guard lives here, at the
+* delete itself, so no caller can issue the DELETE against a coach workout by skipping a check.
+* Throws on a non-ok response.
+*/
+async function removePersonalWorkout(client, args) {
+	const target = (await fetchAthleteWorkouts(client, args.date, args.date)).find((pw) => coerceInt(pw.id) === args.programWorkoutId);
+	if (target === void 0) throw new Error(`No workout with id ${args.programWorkoutId} on ${args.date}. Get the id and date from athlete_workouts.`);
+	if (!isPersonalSession(target)) throw new Error(`Workout ${args.programWorkoutId} on ${args.date} is a coach-scheduled workout, not a personal session, so it can't be removed. To change logged results on a scheduled workout, use athlete_log_set.`);
+	const res = await client.request("DELETE", `/v5/programWorkouts/${args.programWorkoutId}`);
+	if (!res.ok) throw new Error(`Remove personal workout failed (HTTP ${res.status}).`);
+}
+/**
 * Find a personal-calendar session already on the given day. The range marks these with
 * `personal_cal === true`; the addable id is the program workout's `workout_id`. Returns the
 * first one's workoutId, or null when the day has no personal session.
 */
 function findPersonalSessionWorkoutId(workouts) {
 	for (const pw of workouts) {
-		const rec = pw;
-		if (rec.personal_cal === true) {
-			const workoutId = coerceInt(rec.workout_id);
-			if (workoutId !== null) return workoutId;
-		}
+		if (!isPersonalSession(pw)) continue;
+		const workoutId = coerceInt(pw.workout_id);
+		if (workoutId !== null) return workoutId;
 	}
 	return null;
 }
@@ -1345,6 +1459,59 @@ function indexAddedExercises(added) {
 	}
 	return out;
 }
+/**
+* Flatten a day's saved sets into `{ pw, savedWorkoutSetId, ex }` rows (both saved-set keys),
+* carrying the parent program-workout so a caller can read its identity (`personal_cal`, program
+* title) without re-walking. The one saved-copy traversal the by-exercise paths share.
+*/
+function eachPrescribedExercise(workouts) {
+	const rows = [];
+	for (const pw of workouts) {
+		const rec = pw;
+		const ssw = isRecord(rec.summarizedSavedWorkout) ? rec.summarizedSavedWorkout : {};
+		const sw = isRecord(ssw.saved_workout) ? ssw.saved_workout : null;
+		if (!sw) continue;
+		const sets = [...Array.isArray(sw.workoutSets) ? sw.workoutSets : [], ...Array.isArray(sw.addedWorkoutSets) ? sw.addedWorkoutSets : []];
+		for (const s of sets) {
+			if (!isRecord(s)) continue;
+			const savedWorkoutSetId = coerceInt(s.id);
+			if (savedWorkoutSetId === null) continue;
+			const exercises = Array.isArray(s.workoutSetExercises) ? s.workoutSetExercises : [];
+			for (const ex of exercises) if (isRecord(ex)) rows.push({
+				pw: rec,
+				savedWorkoutSetId,
+				ex
+			});
+		}
+	}
+	return rows;
+}
+/**
+* Find prescribed exercises on coach-scheduled (non-personal) workouts that day matching any of the
+* given exercise ids. Used to warn after an ad-hoc log that the same lift was already on the
+* athlete's scheduled workout — a caller can then point at {@link logAthleteSet}. Personal sessions
+* (`personal_cal === true`) are skipped: the ad-hoc log itself lands there, so they are not an
+* alternative. One row per matching saved-set exercise, dropping any with an unresolvable id.
+*/
+function findScheduledMatches(workouts, exerciseIds) {
+	const out = [];
+	for (const { pw, savedWorkoutSetId, ex } of eachPrescribedExercise(workouts)) {
+		if (isPersonalSession(pw)) continue;
+		const exerciseId = coerceInt(ex.exercise_id);
+		const savedWorkoutSetExerciseId = coerceInt(ex.id);
+		if (exerciseId === null || savedWorkoutSetExerciseId === null) continue;
+		if (!exerciseIds.has(exerciseId)) continue;
+		out.push({
+			exerciseId,
+			title: exerciseTitle(ex),
+			program: str(pw.program_title),
+			workoutTitle: str(pw.workout_title) ?? "",
+			savedWorkoutSetId,
+			savedWorkoutSetExerciseId
+		});
+	}
+	return out;
+}
 /** Group resolved exercises by saved set and write each set via the given log target. */
 async function logResolvedExercises(client, target, date, resolved) {
 	const bySet = /* @__PURE__ */ new Map();
@@ -1384,7 +1551,8 @@ async function logResolvedExercises(client, target, date, resolved) {
 */
 async function logAdHocSession(client, args) {
 	if (args.exercises.length === 0) throw new Error("Provide at least one exercise to log.");
-	const existing = findPersonalSessionWorkoutId(await fetchAthleteWorkouts(client, args.date, args.date));
+	const day = await fetchAthleteWorkouts(client, args.date, args.date);
+	const existing = findPersonalSessionWorkoutId(day);
 	const created = existing === null;
 	const workoutId = existing ?? (await createPersonalWorkout(client, args.date)).workoutId;
 	const withOrder = args.exercises.map((e, i) => ({
@@ -1408,11 +1576,30 @@ async function logAdHocSession(client, args) {
 		};
 	});
 	const sets = await logResolvedExercises(client, { role: "athlete" }, args.date, resolved);
-	return {
+	const result = {
 		date: args.date,
 		created,
 		sets
 	};
+	const scheduledAlternatives = findScheduledMatches(day, new Set(args.exercises.map((e) => e.exerciseId)));
+	if (scheduledAlternatives.length > 0) result.scheduledAlternatives = scheduledAlternatives;
+	return result;
+}
+//#endregion
+//#region ../js/src/util.ts
+/**
+* Drop the keys whose value is `undefined`, so the result can be passed to a function or
+* spread into an object under `exactOptionalPropertyTypes` without the per-key
+* `...(x !== undefined ? { x } : {})` dance. Required keys stay required in the result type;
+* optional ones lose `undefined` from their value type.
+*
+* Example:
+*   definedProps({ metric, teamId: maybeId, date })  // omits teamId/date if they're undefined
+*/
+function definedProps(obj) {
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) if (value !== void 0) result[key] = value;
+	return result;
 }
 //#endregion
 //#region ../core/src/history.ts
@@ -1490,6 +1677,7 @@ function registerProfileTools(server, ctx, whoami, userId) {
 	}));
 }
 const ATHLETE_WORKOUTS_DESC = "Workouts in an inclusive YYYY-MM-DD window, flattened to blocks/exercises. Each exercise carries both its `prescribed` sets (what the program called for) and `performed` sets (what the athlete actually logged); each workout has a top-level `logged` flag. Use `performed`/`logged` to tell what was recorded or done. That is the reliable signal: a session can hold logged sets while the API's own completion flags stay 0, and an empty `performed` means nothing was logged for that exercise. For 'did I record anything / what did I do', set loggedOnly:true to return only sessions with logged sets (it keeps whole sessions that have any logged set, so individual exercises inside can still show empty `performed`; it also shrinks a large result); limit returns the most recent N workouts (newest first). For a high-level overview ('what's on my schedule this week', 'what have I been training lately') set summary:true to get one compact row per session (date, program, title, logged flag, and exerciseCount/performedCount — read performedCount against exerciseCount, e.g. 1 of 12 logged) instead of every set — a multi-program week of full detail is large, so prefer summary first, then re-query a single day without it to drill into that day's sets. For 'what's my next workout', query a forward window from today; if it comes back empty, the most recent session is likely yesterday's still-unlogged one, so widen the window backward a day or two. Both filters apply to the presented view, not raw. raw:true returns the untouched API objects. This is a date-windowed fetch, NOT an aggregate: for lifetime totals (all-time session count, total volume, first/last logged date) call athlete_profile instead of summing windows — a multi-year range here can time out. Narrow the window if the result is truncated.";
+const ATHLETE_LOG_TARGETS_DESC = "The savedWorkoutSetId + savedWorkoutSetExerciseId that athlete_log_set needs, read straight off your scheduled/logged workouts in an inclusive YYYY-MM-DD window — no raw needed. This is the self-service path for logging into a COACH-SCHEDULED workout: read the ids here, then pass them to athlete_log_set. The default view is COMPACT: one row per saved set, each carrying its program/programId, the savedWorkoutSetId, and every exercise's savedWorkoutSetExerciseId with prescribed/performed values. When several workouts fall on the same day (you're on more than one program), narrow to one with program (a case-insensitive title substring, e.g. 'bodybuilding' — no id lookup needed), or programId/teamId if you have the id. raw:true returns the untouched API objects, but that blob is large and can be truncated when several workouts share a date — prefer the program filter + the default view. For reading what you actually did (not the log ids), use athlete_workouts.";
 const ATHLETE_EXERCISE_HISTORY_DESC = "Per-exercise PRs and the dated session time-series (sets performed, estimated 1RM). The returned `sessions` run all-time, newest first; pass since/until (YYYY-MM-DD, inclusive) to keep only sessions in that window — use it for 'last 3 months' / 'this year' questions so the result stays small. estimated1RM is a formula off the session's best set and reads high when a session mixes a heavy single with high-rep backdown work, so treat it as approximate, not a logged single. `liftPRs` are always all-time and ignore since/until, but each carries the date it was set, so filter those dates yourself to answer 'PRs set this year'. Set raw:true for the untouched API object. Get the exercise id from athlete_exercises.";
 const ATHLETE_EXERCISES_DESC = "The exercises the athlete has logged (id + title + positional units). Pass q to free-text search by name; use the returned id with athlete_exercise_history, athlete_personal_records, or athlete_exercise_stats (all of which require an exercise id). A common name returns several variants (e.g. plain 'Bench Press' id 1162 vs 'BARBELL BENCH PRESS'); each variant keeps its own separate history and PR board, so prefer the plain canonical entry, and if a PR or trend looks incomplete, the work may be split across variants — check the others.";
 function runAthleteWorkouts(ctx, args) {
@@ -1567,7 +1755,31 @@ function registerExerciseTools(server, ctx, userId) {
 		annotations: READ
 	}, ({ exerciseId, date }) => attempt(async () => jsonResult(await fetchExerciseStats(ctx.client, toId(exerciseId), await userId(), date))));
 }
-/** Create a personal workout session and add exercises to it. */
+/** The compact log-id read: savedWorkoutSetId + savedWorkoutSetExerciseId for athlete_log_set. */
+function registerLogTargetsTool(server, ctx) {
+	server.registerTool("athlete_log_targets", {
+		title: "Saved-workout log ids (for athlete_log_set)",
+		description: ATHLETE_LOG_TARGETS_DESC,
+		inputSchema: {
+			startDate: dateString,
+			endDate: dateString,
+			program: z.string().optional(),
+			programId: idParam.optional(),
+			teamId: idParam.optional(),
+			raw: z.boolean().optional()
+		},
+		annotations: READ
+	}, ({ startDate, endDate, program, programId, teamId, raw }) => attempt(async () => {
+		const workouts = selectWorkoutsByProgram(await fetchAthleteWorkouts(ctx.client, startDate, endDate), definedProps({
+			programTitle: program,
+			programId: programId === void 0 ? void 0 : toId(programId),
+			teamId: teamId === void 0 ? void 0 : toId(teamId)
+		}));
+		if (raw === true) return jsonResult(workouts, { hint: "Each set's id is the savedWorkoutSetId; each savedWorkoutSetExercises[].id is the savedWorkoutSetExerciseId. Large — if truncated, pass program (a title substring) or use the default compact view." });
+		return jsonResult(presentLogTargets(workouts), { hint: "One row per saved set: savedWorkoutSetId plus each savedWorkoutSetExerciseId, with the program it belongs to. Pass both to athlete_log_set. Filter with program (title substring), programId, or teamId if you're on several programs." });
+	}));
+}
+/** Create a personal workout session, add exercises, and remove a stray personal session. */
 function registerSessionTools(server, ctx) {
 	server.registerTool("athlete_session_create", {
 		title: "Create personal workout session",
@@ -1601,6 +1813,27 @@ function registerSessionTools(server, ctx) {
 		}));
 		return jsonResult(await addExercisesToWorkout(ctx.client, toId(workoutId), mapped), { hint: "Each top-level id is a savedWorkoutSetId; savedWorkoutSetExercises[].id is the savedWorkoutSetExerciseId for athlete_log_set." });
 	}));
+	server.registerTool("athlete_session_remove", {
+		title: "Remove a personal workout session",
+		description: "Delete a personal (self-created) workout session from your calendar — use it to clean up a stray ad-hoc session, e.g. one athlete_log_session created when you meant to log into a coach-scheduled workout. Give the programWorkoutId (the `id` of the session in athlete_workouts, where personal:true marks a personal session) and its date. ONLY personal sessions can be removed: the tool re-reads that day and refuses a coach-scheduled workout. Requires confirmation (elicitation or confirm:true).",
+		inputSchema: {
+			...athleteSessionRemoveArgsSchema.shape,
+			confirm: z.boolean().optional()
+		},
+		annotations: DESTRUCTIVE
+	}, ({ programWorkoutId, date, confirm }, extra) => attempt(async () => {
+		const id = toId(programWorkoutId);
+		if (!await confirmGate(server, extra.requestId, `Permanently remove personal session ${id} on ${date}? This deletes the session and anything logged in it.`, confirm)) return errorResult(NOT_CONFIRMED);
+		await removePersonalWorkout(ctx.client, {
+			programWorkoutId: id,
+			date
+		});
+		return jsonResult({
+			removed: true,
+			programWorkoutId: id,
+			date
+		});
+	}));
 }
 /** Map validated logSession exercises to the SDK's SessionExercise[] (ids coerced, slots trimmed). */
 function mapSessionExercises(exercises) {
@@ -1631,14 +1864,16 @@ function registerLogTool(server, ctx) {
 		annotations: DESTRUCTIVE
 	}, ({ date, exercises, confirm }, extra) => attempt(async () => {
 		if (!await confirmGate(server, extra.requestId, `Log a session of ${exercises.length} exercise(s) on ${date}? This writes to your coach-visible training log.`, confirm)) return errorResult(NOT_CONFIRMED);
-		return jsonResult(await logAdHocSession(ctx.client, {
+		const res = await logAdHocSession(ctx.client, {
 			date,
 			exercises: mapSessionExercises(exercises)
-		}));
+		});
+		if (res.scheduledAlternatives !== void 0 && res.scheduledAlternatives.length > 0) return jsonResult(res, { hint: "Heads up: one or more of these lifts were already on a coach-scheduled workout today (see scheduledAlternatives). This logged a SEPARATE personal session. To log into the scheduled workout instead, use athlete_log_set with the savedWorkoutSetId / savedWorkoutSetExerciseId shown there — and athlete_session_remove to delete this personal session if it was a mistake." });
+		return jsonResult(res);
 	}));
 	server.registerTool("athlete_log_set", {
 		title: "Log completed set results",
-		description: "Athlete-facing write: record entered results (reps/weight per set) for a saved workout set on a given day. Writes to the athlete's (coach-visible) training log and shows in exercise history. Each set fills the next position in order; give a set a 1-based `slot` to place it at a specific position — e.g. log three top singles into positions 4-6 of an 8,5,3,1,1,1 ramp. A partial log records only the positions you send (plus any logged in an earlier call) and leaves the rest unlogged, so it does not mark untouched sets as performed. In a superset/circuit the block is marked done only once every exercise in it has logged results, so logging one exercise leaves its siblings untouched (the response's `setCompleted` reports whether the block was completed). Get savedWorkoutSetId + savedWorkoutSetExerciseId from athlete_workouts (raw:true). Requires confirmation (elicitation or confirm:true).",
+		description: "Athlete-facing write: record entered results (reps/weight per set) for a saved workout set on a given day. Writes to the athlete's (coach-visible) training log and shows in exercise history. Each set fills the next position in order; give a set a 1-based `slot` to place it at a specific position — e.g. log three top singles into positions 4-6 of an 8,5,3,1,1,1 ramp. A partial log records only the positions you send (plus any logged in an earlier call) and leaves the rest unlogged, so it does not mark untouched sets as performed. In a superset/circuit the block is marked done only once every exercise in it has logged results, so logging one exercise leaves its siblings untouched (the response's `setCompleted` reports whether the block was completed). Get savedWorkoutSetId + savedWorkoutSetExerciseId from athlete_log_targets (filter by program when several workouts share a date). Requires confirmation (elicitation or confirm:true).",
 		inputSchema: {
 			...logSetArgsSchema.shape,
 			confirm: z.boolean().optional()
@@ -1675,12 +1910,13 @@ function registerAthleteTrainingTools(server, ctx) {
 	};
 	registerProfileTools(server, ctx, whoami, userId);
 	registerExerciseTools(server, ctx, userId);
+	registerLogTargetsTool(server, ctx);
 	registerSessionTools(server, ctx);
 	registerLogTool(server, ctx);
 }
 //#endregion
 //#region package.json
-var version = "1.5.0";
+var version = "1.6.0";
 //#endregion
 //#region src/server.ts
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trainheroic-unofficial/athlete-mcp",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -21,8 +21,8 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "zod": "^4.4.3",
-    "@trainheroic-unofficial/core": "1.5.0",
-    "@trainheroic-unofficial/js": "1.5.0"
+    "@trainheroic-unofficial/core": "1.6.0",
+    "@trainheroic-unofficial/js": "1.6.0"
   },
   "devDependencies": {
     "@types/node": "^26.0.0",