hevy-mcp 3.3.0 → 3.4.1

package/dist/{src-B_mNqS1X.mjs → src-Ch2aS5wP.mjs}

@@ -4,9 +4,9 @@
 (function() {
 	try {
 		var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {};
-		e.SENTRY_RELEASE = { id: "hevy-mcp@3.3.0" };
+		e.SENTRY_RELEASE = { id: "hevy-mcp@3.4.1" };
 		var n = new e.Error().stack;
-		n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "d4c67aeb-89ed-4cf7-ae4a-09c19c187b3d", e._sentryDebugIdIdentifier = "sentry-dbid-d4c67aeb-89ed-4cf7-ae4a-09c19c187b3d");
+		n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "474ddca0-d028-4c83-9184-bac22b12845e", e._sentryDebugIdIdentifier = "sentry-dbid-474ddca0-d028-4c83-9184-bac22b12845e");
 	} catch (e) {}
 })();
 import * as Sentry from "@sentry/node";
@@ -28,6 +28,43 @@ import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import semver from "semver";
+//#region src/utils/sentry-privacy.ts
+const SENTRY_PROHIBITED_MCP_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"mcp.request.id",
+	"mcp.session.id",
+	"mcp.cancelled.request_id",
+	"mcp.cancelled.reason",
+	"mcp.progress.token",
+	"mcp.progress.message",
+	"mcp.resource.uri",
+	"mcp.method.name",
+	"mcp.resource.protocol",
+	"mcp.prompt.name",
+	"mcp.protocol.version",
+	"mcp.logging.message",
+	"mcp.prompt.result.description",
+	"mcp.request.argument",
+	"mcp.logging.logger",
+	"mcp.logging.level",
+	"mcp.client.name",
+	"mcp.client.title",
+	"mcp.client.version"
+]);
+/** Remove MCP correlation and unbounded client fields before Sentry export. */
+function sanitizeSentryMcpSpan(span) {
+	if (!span.data) return span;
+	let sanitizedData;
+	for (const key of SENTRY_PROHIBITED_MCP_ATTRIBUTES) {
+		if (!(key in span.data)) continue;
+		sanitizedData ??= { ...span.data };
+		delete sanitizedData[key];
+	}
+	return sanitizedData ? {
+		...span,
+		data: sanitizedData
+	} : span;
+}
+//#endregion
 //#region src/utils/telemetry.ts
 /**
 * Centralized telemetry initialization.
@@ -40,10 +77,10 @@ import semver from "semver";
 * OTel Collector → Honeycomb: performance traces, metrics
 */
 const name$1 = "hevy-mcp";
-const version$1 = "3.3.0";
+const version$1 = "3.4.1";
 const collectorToken = "NH9vOela-HYreQxAbJa68cjEmORoEKM57EvneUDVcOo";
 const COLLECTOR_ENDPOINT = "https://otel.chrisdoc.dev/v1";
-const sentryRelease = process.env.SENTRY_RELEASE ?? `hevy-mcp@3.3.0`;
+const sentryRelease = process.env.SENTRY_RELEASE ?? `hevy-mcp@3.4.1`;
 const resource = resourceFromAttributes({
 	"service.name": name$1,
 	"service.version": version$1
@@ -52,6 +89,7 @@ const rawDsn = process.env.SENTRY_DSN ?? "https://ce696d8333b507acbf5203eb877bce
 const isValidDsn = typeof rawDsn === "string" && rawDsn.length > 0 && !rawDsn.startsWith("*");
 const sentryClient = Sentry.init({
 	dsn: isValidDsn ? rawDsn : void 0,
+	beforeSendSpan: sanitizeSentryMcpSpan,
 	release: sentryRelease,
 	tracesSampleRate: 1,
 	sendDefaultPii: false,
@@ -82,21 +120,36 @@ tracerProvider.register({
 	propagator: new SentryPropagator(),
 	contextManager: new Sentry.SentryContextManager()
 });
-{
-	const meterProvider = new MeterProvider({
-		resource,
-		readers: [new PeriodicExportingMetricReader({
-			exporter: new OTLPMetricExporter({
-				url: `${COLLECTOR_ENDPOINT}/metrics`,
-				headers: { Authorization: `Bearer ${collectorToken}` }
-			}),
-			exportIntervalMillis: 1e4
-		})]
-	});
-	metrics.setGlobalMeterProvider(meterProvider);
-}
+let meterProvider;
+meterProvider = new MeterProvider({
+	resource,
+	readers: [new PeriodicExportingMetricReader({
+		exporter: new OTLPMetricExporter({
+			url: `${COLLECTOR_ENDPOINT}/metrics`,
+			headers: { Authorization: `Bearer ${collectorToken}` }
+		}),
+		exportIntervalMillis: 1e4
+	})]
+});
+metrics.setGlobalMeterProvider(meterProvider);
 trace.setGlobalTracerProvider(tracerProvider);
 Sentry.validateOpenTelemetrySetup();
+async function flushTelemetry(timeoutMs = 1e3) {
+	const flushPromise = Promise.allSettled([
+		tracerProvider.forceFlush(),
+		...meterProvider ? [meterProvider.forceFlush()] : [],
+		Sentry.flush(timeoutMs)
+	]);
+	let timeout;
+	const timeoutPromise = new Promise((resolve) => {
+		timeout = setTimeout(resolve, timeoutMs);
+	});
+	try {
+		await Promise.race([flushPromise, timeoutPromise]);
+	} finally {
+		clearTimeout(timeout);
+	}
+}
 const tracer = trace.getTracer(name$1);
 const meter = metrics.getMeter(name$1);
 function setCurrentUserHash(hash) {
@@ -111,9 +164,15 @@ function setCurrentUserHash(hash) {
 * for use throughout the codebase. All instruments are sent to Honeycomb
 * via the OTLP metrics exporter configured in telemetry.ts.
 */
-/** Total MCP tool invocations, grouped by tool name. */
+/** Total MCP tool invocations grouped by name and bounded taxonomy. */
 const toolInvocations = meter.createCounter("mcp.tool.invocations", { description: "Total MCP tool invocations" });
-/** Total MCP tool errors, grouped by tool name and error type. */
+/** Total MCP tool outcomes, grouped by bounded taxonomy and outcome. */
+const toolOutcomes = meter.createCounter("mcp.tool.outcomes", { description: "Total MCP tool outcomes" });
+/** Total MCP sessions started, grouped by sanitized client metadata. */
+const sessionStarted = meter.createCounter("mcp.session.started", { description: "Total MCP sessions started" });
+/** Total MCP sessions ended, grouped by bounded termination metadata. */
+const sessionEnded = meter.createCounter("mcp.session.ended", { description: "Total MCP sessions ended" });
+/** Total thrown MCP tool errors grouped by name, taxonomy, and error type. */
 const toolErrors = meter.createCounter("mcp.tool.errors", { description: "Total MCP tool errors" });
 /** MCP tool execution duration in milliseconds. */
 const toolDuration = meter.createHistogram("mcp.tool.duration_ms", {
@@ -547,6 +606,22 @@ function resolveErrorPolicy(error, defaultMessage, notInitializedMessage) {
 	};
 }
 //#endregion
+//#region src/utils/result-telemetry.ts
+function bucketCount(value) {
+	if (!Number.isFinite(value) || value <= 0) return "0";
+	if (value === 1) return "1";
+	if (value <= 10) return "2-10";
+	if (value <= 50) return "11-50";
+	return "51+";
+}
+const resultTelemetry = /* @__PURE__ */ new WeakMap();
+function attachResultTelemetry(result, telemetry) {
+	if (telemetry) resultTelemetry.set(result, telemetry);
+}
+function getResultTelemetry(result) {
+	return resultTelemetry.get(result);
+}
+//#endregion
 //#region src/utils/response-formatter.ts
 function jsonText(data) {
 	return JSON.stringify(data, null, 2) ?? "null";
@@ -564,17 +639,21 @@ function defineStructuredResponseContract(definition) {
 			const structuredContent = z.object(definition.outputSchema).parse(definition.normalize(data));
 			const text = definition.text?.(data, structuredContent) ?? jsonText(definition.legacyJson(structuredContent));
 			const additionalText = definition.additionalText?.(data, structuredContent) ?? [];
-			return {
+			const response = {
 				content: [textContent(text), ...additionalText.map(textContent)],
 				structuredContent
 			};
+			attachResultTelemetry(response, definition.telemetry?.(data));
+			return response;
 		}
 	};
 }
-function defineJsonResponseContract(present) {
+function defineJsonResponseContract(present, telemetry) {
 	return { render(data) {
 		const presentation = present(data);
-		return { content: [textContent(presentation.text ?? jsonText(presentation.json)), ...(presentation.additionalText ?? []).map(textContent)] };
+		const response = { content: [textContent(presentation.text ?? jsonText(presentation.json)), ...(presentation.additionalText ?? []).map(textContent)] };
+		attachResultTelemetry(response, telemetry?.(data));
+		return response;
 	} };
 }
 /** The only public success-response entry point used by tool handlers. */
@@ -955,125 +1034,183 @@ function formatWorkoutEvent(event) {
 	};
 	throw new Error(`Unsupported workout event type: ${event.type}`);
 }
+function exerciseSetCountTelemetry(exercises) {
+	const setCount = exercises.reduce((total, exercise) => total + (exercise.sets?.length ?? 0), 0);
+	return {
+		exerciseCountBucket: bucketCount(exercises.length),
+		setCountBucket: bucketCount(setCount)
+	};
+}
+function workoutResultTelemetry(workout) {
+	const exercises = workout?.exercises ?? [];
+	return {
+		itemCountBucket: bucketCount(workout ? 1 : 0),
+		...exerciseSetCountTelemetry(exercises)
+	};
+}
+function routineResultTelemetry(routine) {
+	const exercises = routine?.exercises ?? [];
+	return {
+		itemCountBucket: bucketCount(routine ? 1 : 0),
+		...exerciseSetCountTelemetry(exercises)
+	};
+}
+const SAFE_WORKFLOW_NAMES = {
+	"training-summary": "training-summary",
+	"routine-discovery": "routine-discovery"
+};
+function workflowResultTelemetry(workflow) {
+	const name = SAFE_WORKFLOW_NAMES[workflow.name];
+	if (!name) return void 0;
+	return {
+		name,
+		pagination: workflow.pagination,
+		cacheStatus: workflow.cacheStatus,
+		itemsScanned: workflow.itemsScanned
+	};
+}
 const workoutsResponse = defineStructuredResponseContract({
 	outputSchema: workoutsOutputSchema,
 	normalize: (workouts) => ({ workouts: workouts?.map(formatWorkout) ?? [] }),
 	legacyJson: ({ workouts }) => workouts,
-	text: (_data, { workouts }) => workouts.length === 0 ? "No workouts found for the specified parameters" : void 0
+	text: (_data, { workouts }) => workouts.length === 0 ? "No workouts found for the specified parameters" : void 0,
+	telemetry: (workouts) => ({ itemCountBucket: bucketCount(workouts?.length ?? 0) })
 });
 const workoutResponse = defineStructuredResponseContract({
 	outputSchema: workoutOutputSchema,
 	normalize: (data) => ({ workout: data.workout ? formatWorkout(data.workout) : null }),
 	legacyJson: ({ workout }) => workout,
-	text: ({ workoutId }, { workout }) => workout === null ? `Workout with ID ${workoutId} not found` : void 0
+	text: ({ workoutId }, { workout }) => workout === null ? `Workout with ID ${workoutId} not found` : void 0,
+	telemetry: ({ workout }) => workoutResultTelemetry(workout)
 });
 const workoutCountResponse = defineStructuredResponseContract({
 	outputSchema: workoutCountOutputSchema,
 	normalize: (count) => ({ count }),
-	legacyJson: (output) => output
+	legacyJson: (output) => output,
+	telemetry: (count) => ({ itemCountBucket: bucketCount(count) })
 });
 const workoutEventsResponse = defineStructuredResponseContract({
 	outputSchema: workoutEventsOutputSchema,
 	normalize: (data) => ({ events: data.events?.map(formatWorkoutEvent) ?? [] }),
 	legacyJson: ({ events }) => events,
-	text: ({ since }, { events }) => events.length === 0 ? `No workout events found for the specified parameters since ${since}` : void 0
+	text: ({ since }, { events }) => events.length === 0 ? `No workout events found for the specified parameters since ${since}` : void 0,
+	telemetry: (data) => ({ itemCountBucket: bucketCount(data.events?.length ?? 0) })
 });
 const routinesResponse = defineStructuredResponseContract({
 	outputSchema: routinesOutputSchema,
 	normalize: (routines) => ({ routines: routines?.map(formatRoutine) ?? [] }),
 	legacyJson: ({ routines }) => routines,
-	text: (_data, { routines }) => routines.length === 0 ? "No routines found for the specified parameters" : void 0
+	text: (_data, { routines }) => routines.length === 0 ? "No routines found for the specified parameters" : void 0,
+	telemetry: (routines) => ({ itemCountBucket: bucketCount(routines?.length ?? 0) })
 });
 const routineResponse = defineStructuredResponseContract({
 	outputSchema: routineOutputSchema,
 	normalize: (data) => ({ routine: data.routine ? formatRoutine(data.routine) : null }),
 	legacyJson: ({ routine }) => routine,
-	text: ({ routineId }, { routine }) => routine === null ? `Routine with ID ${routineId} not found` : void 0
+	text: ({ routineId }, { routine }) => routine === null ? `Routine with ID ${routineId} not found` : void 0,
+	telemetry: ({ routine }) => routineResultTelemetry(routine)
 });
 const exerciseTemplatesResponse = defineStructuredResponseContract({
 	outputSchema: exerciseTemplatesOutputSchema,
 	normalize: (templates) => ({ exerciseTemplates: templates?.map(formatExerciseTemplate) ?? [] }),
 	legacyJson: ({ exerciseTemplates }) => exerciseTemplates,
-	text: (_data, { exerciseTemplates }) => exerciseTemplates.length === 0 ? "No exercise templates found for the specified parameters" : void 0
+	text: (_data, { exerciseTemplates }) => exerciseTemplates.length === 0 ? "No exercise templates found for the specified parameters" : void 0,
+	telemetry: (templates) => ({ itemCountBucket: bucketCount(templates?.length ?? 0) })
 });
 const exerciseTemplateResponse = defineStructuredResponseContract({
 	outputSchema: exerciseTemplateOutputSchema,
 	normalize: (data) => ({ exerciseTemplate: data.exerciseTemplate ? formatExerciseTemplate(data.exerciseTemplate) : null }),
 	legacyJson: ({ exerciseTemplate }) => exerciseTemplate,
-	text: ({ exerciseTemplateId }, { exerciseTemplate }) => exerciseTemplate === null ? `Exercise template with ID ${exerciseTemplateId} not found` : void 0
+	text: ({ exerciseTemplateId }, { exerciseTemplate }) => exerciseTemplate === null ? `Exercise template with ID ${exerciseTemplateId} not found` : void 0,
+	telemetry: ({ exerciseTemplate }) => ({ itemCountBucket: bucketCount(exerciseTemplate ? 1 : 0) })
 });
 const exerciseHistoryResponse = defineStructuredResponseContract({
 	outputSchema: exerciseHistoryOutputSchema,
 	normalize: (data) => ({ exerciseHistory: data.history?.map(formatExerciseHistoryEntry) ?? [] }),
 	legacyJson: ({ exerciseHistory }) => exerciseHistory,
-	text: ({ exerciseTemplateId }, { exerciseHistory }) => exerciseHistory.length === 0 ? `No exercise history found for template ${exerciseTemplateId}` : void 0
+	text: ({ exerciseTemplateId }, { exerciseHistory }) => exerciseHistory.length === 0 ? `No exercise history found for template ${exerciseTemplateId}` : void 0,
+	telemetry: (data) => ({ itemCountBucket: bucketCount(data.history?.length ?? 0) })
 });
 const searchExerciseTemplatesResponse = defineStructuredResponseContract({
 	outputSchema: exerciseTemplatesOutputSchema,
 	normalize: (data) => ({ exerciseTemplates: data.results.map(formatExerciseTemplate) }),
 	legacyJson: ({ exerciseTemplates }) => exerciseTemplates,
-	text: ({ query, primaryMuscleGroup }, { exerciseTemplates }) => exerciseTemplates.length === 0 ? `No exercise templates found matching "${query}"${primaryMuscleGroup ? ` with primary muscle group "${primaryMuscleGroup}"` : ""}` : void 0
+	text: ({ query, primaryMuscleGroup }, { exerciseTemplates }) => exerciseTemplates.length === 0 ? `No exercise templates found matching "${query}"${primaryMuscleGroup ? ` with primary muscle group "${primaryMuscleGroup}"` : ""}` : void 0,
+	telemetry: (data) => ({ itemCountBucket: bucketCount(data.results.length) })
 });
 const routineFoldersResponse = defineStructuredResponseContract({
 	outputSchema: routineFoldersOutputSchema,
 	normalize: (folders) => ({ routineFolders: folders?.map(formatRoutineFolder) ?? [] }),
 	legacyJson: ({ routineFolders }) => routineFolders,
-	text: (_data, { routineFolders }) => routineFolders.length === 0 ? "No routine folders found for the specified parameters" : void 0
+	text: (_data, { routineFolders }) => routineFolders.length === 0 ? "No routine folders found for the specified parameters" : void 0,
+	telemetry: (folders) => ({ itemCountBucket: bucketCount(folders?.length ?? 0) })
 });
 const routineFolderResponse = defineStructuredResponseContract({
 	outputSchema: routineFolderOutputSchema,
 	normalize: (data) => ({ routineFolder: data.routineFolder ? formatRoutineFolder(data.routineFolder) : null }),
 	legacyJson: ({ routineFolder }) => routineFolder,
-	text: ({ folderId }, { routineFolder }) => routineFolder === null ? `Routine folder with ID ${folderId} not found` : void 0
+	text: ({ folderId }, { routineFolder }) => routineFolder === null ? `Routine folder with ID ${folderId} not found` : void 0,
+	telemetry: ({ routineFolder }) => ({ itemCountBucket: bucketCount(routineFolder ? 1 : 0) })
 });
 const bodyMeasurementsResponse = defineStructuredResponseContract({
 	outputSchema: bodyMeasurementsOutputSchema,
 	normalize: (measurements) => ({ bodyMeasurements: measurements?.map(formatBodyMeasurement) ?? [] }),
 	legacyJson: ({ bodyMeasurements }) => bodyMeasurements,
-	text: (_data, { bodyMeasurements }) => bodyMeasurements.length === 0 ? "No body measurements found for the specified parameters" : void 0
+	text: (_data, { bodyMeasurements }) => bodyMeasurements.length === 0 ? "No body measurements found for the specified parameters" : void 0,
+	telemetry: (measurements) => ({ itemCountBucket: bucketCount(measurements?.length ?? 0) })
 });
 const bodyMeasurementResponse = defineStructuredResponseContract({
 	outputSchema: bodyMeasurementOutputSchema,
 	normalize: (data) => ({ bodyMeasurement: data.bodyMeasurement ? formatBodyMeasurement(data.bodyMeasurement) : null }),
 	legacyJson: ({ bodyMeasurement }) => bodyMeasurement,
-	text: ({ date }, { bodyMeasurement }) => bodyMeasurement === null ? `No body measurement found for date ${date}` : void 0
+	text: ({ date }, { bodyMeasurement }) => bodyMeasurement === null ? `No body measurement found for date ${date}` : void 0,
+	telemetry: ({ bodyMeasurement }) => ({ itemCountBucket: bucketCount(bodyMeasurement ? 1 : 0) })
 });
 const userResponse = defineStructuredResponseContract({
 	outputSchema: userOutputSchema,
 	normalize: (user) => ({ user: user ?? null }),
 	legacyJson: ({ user }) => user,
-	text: (_data, { user }) => user === null ? "No user info found for the authenticated user" : void 0
+	text: (_data, { user }) => user === null ? "No user info found for the authenticated user" : void 0,
+	telemetry: (user) => ({ itemCountBucket: bucketCount(user ? 1 : 0) })
 });
 const trainingSummaryResponse = defineStructuredResponseContract({
 	outputSchema: trainingSummaryOutputSchema,
 	normalize: (data) => data,
 	legacyJson: (output) => output,
-	text: (data) => data.workouts.count === 0 && data.bodyMeasurements.count === 0 ? "No workouts or body measurements found for the specified period" : void 0
+	text: (data) => data.workouts.count === 0 && data.bodyMeasurements.count === 0 ? "No workouts or body measurements found for the specified period" : void 0,
+	telemetry: (data) => ({
+		itemCountBucket: bucketCount(data.workouts.count + data.bodyMeasurements.count),
+		workflow: workflowResultTelemetry(data.workflow)
+	})
 });
 const compactRoutinesResponse = defineStructuredResponseContract({
 	outputSchema: compactRoutinesOutputSchema,
 	normalize: (data) => data,
 	legacyJson: ({ routines }) => routines,
-	text: (_data, { routines }) => routines.length === 0 ? "No routines found matching the query" : void 0
+	text: (_data, { routines }) => routines.length === 0 ? "No routines found matching the query" : void 0,
+	telemetry: (data) => ({
+		itemCountBucket: bucketCount(data.routines.length),
+		workflow: workflowResultTelemetry(data.workflow)
+	})
 });
-const createWorkoutResponse = defineJsonResponseContract((workout) => workout ? { json: formatWorkout(workout) } : { text: "Failed to create workout: Server returned no data" });
-const updateWorkoutResponse = defineJsonResponseContract((data) => data.workout ? { json: formatWorkout(data.workout) } : { text: `Failed to update workout with ID ${data.workoutId}` });
+const createWorkoutResponse = defineJsonResponseContract((workout) => workout ? { json: formatWorkout(workout) } : { text: "Failed to create workout: Server returned no data" }, (workout) => workoutResultTelemetry(workout));
+const updateWorkoutResponse = defineJsonResponseContract((data) => data.workout ? { json: formatWorkout(data.workout) } : { text: `Failed to update workout with ID ${data.workoutId}` }, (data) => workoutResultTelemetry(data.workout));
 const repRangeDisplayWarningText = "Note: Hevy's public API stores rep ranges (rep_range), but the Hevy apps may not display them because they rely on an internal-only exercise field (input_modifier). See https://github.com/chrisdoc/hevy-mcp/issues/261 for details/workarounds.";
 const createRoutineResponse = defineJsonResponseContract((data) => data.routine ? {
 	json: formatRoutine(data.routine),
 	additionalText: data.usesRepRanges ? [repRangeDisplayWarningText] : []
-} : { text: "Failed to create routine: Server returned no data" });
+} : { text: "Failed to create routine: Server returned no data" }, (data) => routineResultTelemetry(data.routine));
 const updateRoutineResponse = defineJsonResponseContract((data) => data.routine ? {
 	json: formatRoutine(data.routine),
 	additionalText: data.usesRepRanges ? [repRangeDisplayWarningText] : []
-} : { text: `Failed to update routine with ID ${data.routineId}` });
+} : { text: `Failed to update routine with ID ${data.routineId}` }, (data) => routineResultTelemetry(data.routine));
 const createExerciseTemplateResponse = defineJsonResponseContract((response) => ({ json: {
 	id: response?.id,
 	message: "Exercise template created successfully"
 } }));
-const createRoutineFolderResponse = defineJsonResponseContract((folder) => folder ? { json: formatRoutineFolder(folder) } : { text: "Failed to create routine folder: Server returned no data" });
-const createBodyMeasurementResponse = defineJsonResponseContract((date) => ({ text: `Body measurement for ${date} created successfully.` }));
-const updateBodyMeasurementResponse = defineJsonResponseContract((date) => ({ text: `Body measurement for ${date} updated successfully.` }));
+const createRoutineFolderResponse = defineJsonResponseContract((folder) => folder ? { json: formatRoutineFolder(folder) } : { text: "Failed to create routine folder: Server returned no data" }, (folder) => ({ itemCountBucket: bucketCount(folder ? 1 : 0) }));
+const createBodyMeasurementResponse = defineJsonResponseContract((date) => ({ text: `Body measurement for ${date} created successfully.` }), () => ({ itemCountBucket: "1" }));
+const updateBodyMeasurementResponse = defineJsonResponseContract((date) => ({ text: `Body measurement for ${date} updated successfully.` }), () => ({ itemCountBucket: "1" }));
 //#endregion
 //#region src/resources/hevy.ts
 const JSON_MIME_TYPE = "application/json";
@@ -1126,7 +1263,7 @@ function registerHevyResources(server, runtime) {
 //#endregion
 //#region src/server-metadata.ts
 const SERVER_NAME = "hevy-mcp";
-const SERVER_VERSION = "3.3.0";
+const SERVER_VERSION = "3.4.1";
 const SERVER_INSTRUCTIONS = [
 	"Hevy MCP connects clients to the authenticated user's Hevy workout-tracking data, including workouts, routines, exercise templates, routine folders, body measurements, and profile information. HEVY_API_KEY must contain a valid Hevy API key for local stdio use.",
 	"Safety: all get-* and search-* tools are read-only. create-* and update-* tools mutate Hevy data. Creates are additive and non-idempotent, so repeating one can create duplicates. Updates can overwrite existing data. Delete operations are not available.",
@@ -1181,8 +1318,11 @@ function createTypedToolHandler(schema, handler) {
 //#region src/tools/define-tool.ts
 function registerToolDefinition(server, runtime, definition) {
 	const directHandler = createTypedToolHandler(definition.inputSchema, async (args) => respond(definition.responseContract, await definition.execute(runtime, args)));
-	const handler = runtime.wrapHandler(directHandler, definition.name);
-	const callback = (args) => handler(args);
+	const callback = runtime.wrapHandler(directHandler, definition.name, {
+		feature: definition.feature,
+		kind: definition.kind,
+		operation: definition.operation
+	});
 	if (definition.kind === "read") {
 		server.registerTool(definition.name, {
 			description: definition.description,
@@ -1486,6 +1626,8 @@ const updateBodyMeasurementSchema = {
 const bodyMeasurementToolDefinitions = [
 	{
 		name: "get-body-measurements",
+		feature: "measurements",
+		operation: "list",
 		description: describeTool({
 			summary: "Read-only. Lists dated body measurements for the account.",
 			aliases: [
@@ -1511,6 +1653,8 @@ const bodyMeasurementToolDefinitions = [
 	},
 	{
 		name: "get-body-measurement",
+		feature: "measurements",
+		operation: "get",
 		description: describeTool({
 			summary: "Read-only. Retrieves the body measurement entry for one date.",
 			aliases: [
@@ -1536,6 +1680,8 @@ const bodyMeasurementToolDefinitions = [
 	},
 	{
 		name: "create-body-measurement",
+		feature: "measurements",
+		operation: "create",
 		description: describeTool({
 			summary: "Writes to the Hevy account by creating a dated body measurement.",
 			aliases: [
@@ -1561,6 +1707,8 @@ const bodyMeasurementToolDefinitions = [
 	},
 	{
 		name: "update-body-measurement",
+		feature: "measurements",
+		operation: "update",
 		description: describeTool({
 			summary: "Mutates the Hevy account by updating a body measurement for a date.",
 			aliases: [
@@ -1595,6 +1743,8 @@ const createRoutineFolderSchema = { name: z.string().min(1) };
 const folderToolDefinitions = [
 	{
 		name: "get-routine-folders",
+		feature: "folders",
+		operation: "list",
 		description: describeTool({
 			summary: "Read-only. Lists default and custom routine folders.",
 			aliases: [
@@ -1620,6 +1770,8 @@ const folderToolDefinitions = [
 	},
 	{
 		name: "get-routine-folder",
+		feature: "folders",
+		operation: "get",
 		description: describeTool({
 			summary: "Read-only. Retrieves one routine folder's metadata by ID.",
 			aliases: [
@@ -1645,6 +1797,8 @@ const folderToolDefinitions = [
 	},
 	{
 		name: "create-routine-folder",
+		feature: "folders",
+		operation: "create",
 		description: describeTool({
 			summary: "Writes to the Hevy account by creating a new routine folder.",
 			aliases: [
@@ -1673,6 +1827,8 @@ const getRoutinesSchema = paginationShape({
 });
 const getRoutinesDefinition = {
 	name: "get-routines",
+	feature: "routines",
+	operation: "list",
 	description: describeTool({
 		summary: "Read-only. Lists custom and default workout routines.",
 		aliases: [
@@ -1698,6 +1854,8 @@ const getRoutinesDefinition = {
 const getRoutineSchema = { routineId: nonEmptyId };
 const getRoutineDefinition = {
 	name: "get-routine",
+	feature: "routines",
+	operation: "get",
 	description: describeTool({
 		summary: "Read-only. Retrieves one routine and its exercise configuration by ID.",
 		aliases: [
@@ -1724,6 +1882,8 @@ const routineExercisesSchema = z.preprocess(parseJsonArray, z.array(z.object(rou
 const createRoutineSchema = routinePayloadShape;
 const createRoutineDefinition = {
 	name: "create-routine",
+	feature: "routines",
+	operation: "create",
 	description: describeTool({
 		summary: "Writes to the Hevy account by creating a new workout routine.",
 		aliases: [
@@ -1758,6 +1918,8 @@ const routineToolDefinitions = [
 	createRoutineDefinition,
 	{
 		name: "update-routine",
+		feature: "routines",
+		operation: "update",
 		description: describeTool({
 			summary: "Mutates the Hevy account by replacing an existing routine's content.",
 			aliases: [
@@ -1811,6 +1973,8 @@ const searchExerciseTemplatesSchema = {
 const templateToolDefinitions = [
 	{
 		name: "get-exercise-templates",
+		feature: "templates",
+		operation: "list",
 		description: describeTool({
 			summary: "Read-only. Lists default and custom exercise templates with equipment and muscle metadata.",
 			aliases: [
@@ -1836,6 +2000,8 @@ const templateToolDefinitions = [
 	},
 	{
 		name: "get-exercise-template",
+		feature: "templates",
+		operation: "get",
 		description: describeTool({
 			summary: "Read-only. Retrieves complete metadata for one exercise template by ID.",
 			aliases: [
@@ -1861,6 +2027,8 @@ const templateToolDefinitions = [
 	},
 	{
 		name: "get-exercise-history",
+		feature: "templates",
+		operation: "get",
 		description: describeTool({
 			summary: "Read-only. Retrieves past performed sets for one exercise template.",
 			aliases: [
@@ -1889,6 +2057,8 @@ const templateToolDefinitions = [
 	},
 	{
 		name: "create-exercise-template",
+		feature: "templates",
+		operation: "create",
 		description: describeTool({
 			summary: "Writes to the Hevy account by creating a custom exercise template.",
 			aliases: [
@@ -1916,6 +2086,8 @@ const templateToolDefinitions = [
 	},
 	{
 		name: "search-exercise-templates",
+		feature: "templates",
+		operation: "search",
 		description: describeTool({
 			summary: "Read-only for the Hevy account. Searches the full exercise template catalog by title substring.",
 			aliases: [
@@ -1965,6 +2137,8 @@ const templateToolDefinitions = [
 ];
 const userToolDefinitions = [{
 	name: "get-user-info",
+	feature: "profile",
+	operation: "get",
 	description: describeTool({
 		summary: "Read-only. Returns the authenticated account's user ID, display name, and public profile URL.",
 		aliases: [
@@ -2033,6 +2207,8 @@ async function discoverRoutines(runtime, { query, limit }) {
 }
 const routineDiscoveryToolDefinitions = [{
 	name: "search-routines",
+	feature: "workflows",
+	operation: "search",
 	description: describeTool({
 		summary: "Read-only. Discovers routines by title and returns compact metadata without full set payloads.",
 		aliases: [
@@ -2194,6 +2370,8 @@ async function getTrainingSummary(runtime, weeks) {
 }
 const workflowToolDefinitions = [{
 	name: "get-training-summary",
+	feature: "workflows",
+	operation: "get",
 	description: describeTool({
 		summary: "Read-only. Summarizes recent workout activity and body-measurement trends in one call.",
 		aliases: [
@@ -2237,6 +2415,8 @@ const hevyToolDefinitions = [
 	...[
 		{
 			name: "get-workouts",
+			feature: "workouts",
+			operation: "list",
 			description: describeTool({
 				summary: "Read-only. Lists workouts from newest to oldest with exercise and timing details.",
 				aliases: [
@@ -2261,6 +2441,8 @@ const hevyToolDefinitions = [
 		},
 		{
 			name: "get-workout",
+			feature: "workouts",
+			operation: "get",
 			description: describeTool({
 				summary: "Read-only. Retrieves complete details for one workout by its ID.",
 				aliases: [
@@ -2285,6 +2467,8 @@ const hevyToolDefinitions = [
 		},
 		{
 			name: "get-workout-count",
+			feature: "workouts",
+			operation: "count",
 			description: describeTool({
 				summary: "Read-only. Returns the total workout count for the account.",
 				aliases: [
@@ -2306,6 +2490,8 @@ const hevyToolDefinitions = [
 		},
 		{
 			name: "get-workout-events",
+			feature: "workouts",
+			operation: "sync",
 			description: describeTool({
 				summary: "Read-only. Lists workout update and delete events since a timestamp, newest first.",
 				aliases: [
@@ -2334,6 +2520,8 @@ const hevyToolDefinitions = [
 		},
 		{
 			name: "create-workout",
+			feature: "workouts",
+			operation: "create",
 			description: describeTool({
 				summary: "Writes to the Hevy account by creating a new workout.",
 				aliases: [
@@ -2354,6 +2542,8 @@ const hevyToolDefinitions = [
 		},
 		{
 			name: "update-workout",
+			feature: "workouts",
+			operation: "update",
 			description: describeTool({
 				summary: "Mutates the Hevy account by replacing an existing workout.",
 				aliases: [
@@ -2389,70 +2579,6 @@ function registerHevyTools(server, runtime) {
 	for (const definition of hevyToolDefinitions) registerToolDefinition(server, runtime, definition);
 }
 //#endregion
-//#region src/utils/error-handler.ts
-/**
-* Centralized error handling utility for MCP tools
-*/
-/**
-* Create a standardized error response for MCP tools
-*
-* @param error - The error object or message
-* @param context - Optional context information about where the error occurred
-* @returns A formatted MCP tool response with error information
-*/
-function createErrorResponse(error, context) {
-	const policy = resolveErrorPolicy(error, "The request failed unexpectedly. Please try again.", HEVY_CLIENT_NOT_INITIALIZED_ERROR);
-	const { diagnostic } = policy;
-	const axiosErrorContext = diagnostic.status !== void 0 || diagnostic.method !== void 0 || diagnostic.endpoint !== void 0 ? {
-		status: diagnostic.status,
-		method: diagnostic.method,
-		url: diagnostic.endpoint
-	} : null;
-	const errorContext = {
-		sourceContext: context,
-		originalErrorMessage: `${diagnostic.category} occurred`,
-		errorCode: diagnostic.code,
-		errorType: policy.type,
-		axios: axiosErrorContext ?? void 0
-	};
-	const formattedMessage = `${context ? `[${context}] ` : ""}Error: ${policy.message}`;
-	console.error("MCP tool failure", diagnostic);
-	return {
-		content: [{
-			type: "text",
-			text: formattedMessage
-		}],
-		isError: true,
-		errorContext
-	};
-}
-/**
-* Wrap an async function with standardized error handling
-*
-* This function preserves the parameter types of the wrapped function while
-* providing error handling. The returned function accepts Record<string, unknown>
-* (as required by MCP SDK) but internally casts to the original parameter type.
-*
-* @param fn - The async function to wrap
-* @param context - Context information for error messages
-* @returns A function that catches errors and returns standardized error responses
-*/
-function withErrorHandling(fn, context, onError) {
-	return async (rawArgs) => {
-		const args = rawArgs ?? {};
-		try {
-			return await fn(args);
-		} catch (error) {
-			try {
-				onError?.(error, context, Object.keys(args).length);
-			} catch {
-				console.error("MCP error observer failure", { category: "ObserverError" });
-			}
-			return createErrorResponse(error, context);
-		}
-	};
-}
-//#endregion
 //#region src/utils/cache.ts
 /**
 * Shared in-memory cache for async fetches with TTL, LRU eviction,
@@ -3315,7 +3441,8 @@ function createNativeClient(apiKey, baseUrl, options) {
 					method,
 					endpoint,
 					status: response.status,
-					durationMs: Date.now() - startedAt
+					durationMs: Date.now() - startedAt,
+					retryCount
 				});
 				return {
 					data,
@@ -3330,14 +3457,21 @@ function createNativeClient(apiKey, baseUrl, options) {
 					code: normalized.signal?.aborted ? HEVY_REQUEST_ABORTED_ERROR_CODE : getNetworkCode(cause),
 					cause
 				});
+				const canRetry = method === "GET" && isRetryable(error);
+				if (canRetry && retryCount >= maxGetRetries) {
+					error.hevyRetryExhausted = true;
+					error.hevyRetryCount = retryCount;
+					error.code = HEVY_RETRY_EXHAUSTED_ERROR_CODE;
+				}
 				options.onRequestComplete?.({
 					method,
 					endpoint,
 					status: error.status ?? 0,
 					durationMs: Date.now() - startedAt,
+					retryCount,
 					error
 				});
-				if (!(method === "GET" && isRetryable(error))) {
+				if (!canRetry) {
 					emitClientLog(options.logger, {
 						level: "error",
 						logger: "hevy-api",
@@ -3350,12 +3484,7 @@ function createNativeClient(apiKey, baseUrl, options) {
 					});
 					throw error;
 				}
-				if (retryCount >= maxGetRetries) {
-					error.hevyRetryExhausted = true;
-					error.hevyRetryCount = retryCount;
-					error.code = HEVY_RETRY_EXHAUSTED_ERROR_CODE;
-					throw error;
-				}
+				if (error.hevyRetryExhausted) throw error;
 				retryCount += 1;
 				const delayMs = getRetryDelayMs(error, retryCount);
 				emitClientLog(options.logger, {
@@ -3449,8 +3578,69 @@ function createMcpClientLogger(server) {
 	};
 }
 //#endregion
+//#region src/utils/error-handler.ts
+/**
+* Centralized error handling utility for MCP tools
+*/
+/**
+* Create a standardized error response for MCP tools
+*
+* @param error - The error object or message
+* @param context - Optional context information about where the error occurred
+* @returns A formatted MCP tool response with error information
+*/
+function createErrorResponse(error, context) {
+	const policy = resolveErrorPolicy(error, "The request failed unexpectedly. Please try again.", HEVY_CLIENT_NOT_INITIALIZED_ERROR);
+	const { diagnostic } = policy;
+	const axiosErrorContext = diagnostic.status !== void 0 || diagnostic.method !== void 0 || diagnostic.endpoint !== void 0 ? {
+		status: diagnostic.status,
+		method: diagnostic.method,
+		url: diagnostic.endpoint
+	} : null;
+	const errorContext = {
+		sourceContext: context,
+		originalErrorMessage: `${diagnostic.category} occurred`,
+		errorCode: diagnostic.code,
+		errorType: policy.type,
+		axios: axiosErrorContext ?? void 0
+	};
+	const formattedMessage = `${context ? `[${context}] ` : ""}Error: ${policy.message}`;
+	console.error("MCP tool failure", diagnostic);
+	return {
+		content: [{
+			type: "text",
+			text: formattedMessage
+		}],
+		isError: true,
+		errorContext
+	};
+}
+/**
+* Wrap an async function with standardized error handling
+*
+* @param fn - The async function to wrap
+* @param context - Context information for error messages
+* @returns A function that catches errors and returns standardized error responses
+*/
+function withErrorHandling(fn, context, onError) {
+	return async (rawArgs) => {
+		const normalizedArgs = rawArgs ?? {};
+		try {
+			return await fn(normalizedArgs);
+		} catch (error) {
+			try {
+				onError?.(error, context, Object.keys(normalizedArgs).length);
+			} catch {
+				console.error("MCP error observer failure", { category: "ObserverError" });
+			}
+			return createErrorResponse(error, context);
+		}
+	};
+}
+//#endregion
 //#region src/tools/tool-runtime.ts
-function createToolRuntime({ client, catalog, logger, wrapHandler = withErrorHandling }) {
+const defaultToolHandlerWrapper = (fn, context) => withErrorHandling(fn, context);
+function createToolRuntime({ client, catalog, logger, wrapHandler = defaultToolHandlerWrapper }) {
 	return {
 		client,
 		catalog,
@@ -3502,7 +3692,7 @@ function createSharedMcpServer(options) {
 		client: hevyClient,
 		catalog: createExerciseTemplateCatalog(hevyClient),
 		logger,
-		wrapHandler: options.wrapHandler ?? withErrorHandling
+		wrapHandler: options.wrapHandler ?? defaultToolHandlerWrapper
 	});
 	const counting = createToolCountingServer(server);
 	registerHevyTools(counting.server, runtime);
@@ -3541,10 +3731,24 @@ function flushStdout(stdout = process.stdout) {
 		}
 	});
 }
-function installGracefulShutdown({ target, process: processLike = process, logError = console.error, flush = flushStdout, forcedExitTimeoutMs = FORCED_EXIT_TIMEOUT_MS, scheduleForcedExit = setTimeout }) {
+function installGracefulShutdown({ target, process: processLike = process, logError = console.error, flush = flushStdout, forcedExitTimeoutMs = FORCED_EXIT_TIMEOUT_MS, scheduleForcedExit = setTimeout, onComplete }) {
 	let listenersInstalled = true;
 	let shutdownSettled = false;
 	let shutdownPromise;
+	let completionReported = false;
+	const reportCompletion = (succeeded) => {
+		if (completionReported) return void 0;
+		completionReported = true;
+		try {
+			const completion = onComplete?.(succeeded);
+			return completion ? Promise.resolve(completion).catch(() => {
+				logError("Graceful shutdown completion observer failed");
+			}) : void 0;
+		} catch {
+			logError("Graceful shutdown completion observer failed");
+			return;
+		}
+	};
 	const cleanup = () => {
 		if (!listenersInstalled || shutdownPromise && !shutdownSettled) return;
 		listenersInstalled = false;
@@ -3557,7 +3761,8 @@ function installGracefulShutdown({ target, process: processLike = process, logEr
 		if (shutdownPromise) return;
 		if (processLike.exitCode == null) processLike.exitCode = 0;
 		scheduleForcedExit(() => {
-			processLike.exit(processLike.exitCode ?? 0);
+			reportCompletion(false);
+			processLike.exit(shutdownSettled ? processLike.exitCode ?? 0 : 1);
 		}, forcedExitTimeoutMs).unref();
 		shutdownPromise = (async () => {
 			logError(`Shutting down gracefully after ${signal}`);
@@ -3582,6 +3787,7 @@ function installGracefulShutdown({ target, process: processLike = process, logEr
 					return;
 				}
 			} finally {
+				await reportCompletion(!shutdownFailed);
 				shutdownSettled = true;
 				cleanup();
 			}
@@ -3694,135 +3900,304 @@ function createNodeHevyClientOptions() {
 	return {
 		...timeoutMs ? { timeoutMs } : {},
 		onRequestComplete(observation) {
+			const retryCountBucket = bucketCount(observation.retryCount);
+			const diagnostic = observation.error ? createSafeErrorDiagnostic(observation.error) : void 0;
+			const safeErrorAttributes = diagnostic ? {
+				error_category: diagnostic.category,
+				...diagnostic.code ? { error_code: diagnostic.code } : {}
+			} : {};
 			const span = tracer.startSpan(`hevy.api.${observation.method}`, { attributes: {
 				"http.method": observation.method,
 				"http.status_code": observation.status,
+				"hevy.api.retry_count_bucket": retryCountBucket,
 				"hevy.api.endpoint": observation.endpoint
 			} });
 			span.setStatus({ code: observation.error ? SpanStatusCode.ERROR : SpanStatusCode.OK });
-			if (observation.error) {
-				const diagnostic = createSafeErrorDiagnostic(observation.error);
-				span.addEvent("hevy.api.failure", {
-					"error.category": diagnostic.category,
-					...diagnostic.code ? { "error.code": diagnostic.code } : {}
-				});
-			}
+			if (diagnostic) span.addEvent("hevy.api.failure", {
+				"error.category": diagnostic.category,
+				...diagnostic.code ? { "error.code": diagnostic.code } : {}
+			});
 			span.end();
 			apiCalls.add(1, {
 				method: observation.method,
 				endpoint: observation.endpoint,
-				status_code: observation.status
+				status_code: observation.status,
+				retry_count_bucket: retryCountBucket,
+				...safeErrorAttributes
 			});
 			apiDuration.record(observation.durationMs, {
 				method: observation.method,
-				endpoint: observation.endpoint
+				endpoint: observation.endpoint,
+				retry_count_bucket: retryCountBucket,
+				...safeErrorAttributes
 			});
 			debugLog("api_response", {
 				method: observation.method,
 				endpoint: observation.endpoint,
 				durationMs: observation.durationMs,
-				status: observation.status || null
+				status: observation.status || null,
+				retryCountBucket,
+				...safeErrorAttributes
 			});
 		}
 	};
 }
 //#endregion
+//#region src/utils/mcp-session-observability.ts
+const UNKNOWN_METADATA = "unknown";
+const MAX_METADATA_LENGTH = 64;
+const SAFE_METADATA_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._+:/@-]{0,63}$/u;
+let currentSession;
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeMetadata(value) {
+	if (typeof value !== "string") return UNKNOWN_METADATA;
+	const normalized = value.trim();
+	if (normalized.length === 0 || normalized.length > MAX_METADATA_LENGTH || !SAFE_METADATA_PATTERN.test(normalized)) return UNKNOWN_METADATA;
+	return normalized;
+}
+function getInitializeParams(message) {
+	if (!isRecord(message) || message.method !== "initialize") return {};
+	return isRecord(message.params) ? message.params : {};
+}
+function extractMcpClientMetadata(message) {
+	const params = getInitializeParams(message);
+	const clientInfo = isRecord(params.clientInfo) ? params.clientInfo : {};
+	return {
+		name: normalizeMetadata(clientInfo.name),
+		version: normalizeMetadata(clientInfo.version),
+		protocolVersion: normalizeMetadata(params.protocolVersion)
+	};
+}
+function metadataAttributes(metadata) {
+	return {
+		client_name: metadata.name,
+		client_version: metadata.version,
+		protocol_version: metadata.protocolVersion,
+		transport: "stdio"
+	};
+}
+function durationBucket(durationMs) {
+	if (durationMs < 1e3) return "<1s";
+	if (durationMs < 1e4) return "1-10s";
+	if (durationMs < 6e4) return "10-60s";
+	if (durationMs < 3e5) return "1-5m";
+	return "5m+";
+}
+function recordMcpSessionStart(message) {
+	const metadata = extractMcpClientMetadata(message);
+	currentSession = {
+		metadata,
+		startedAt: Date.now(),
+		toolCalls: 0,
+		hadToolFailure: false
+	};
+	const attributes = metadataAttributes(metadata);
+	sessionStarted.add(1, attributes);
+	return metadata;
+}
+function recordMcpToolInvocation() {
+	if (currentSession) currentSession.toolCalls += 1;
+	return metadataAttributes(currentSession?.metadata ?? {
+		name: UNKNOWN_METADATA,
+		version: UNKNOWN_METADATA,
+		protocolVersion: UNKNOWN_METADATA
+	});
+}
+function recordMcpToolFailure() {
+	if (currentSession) currentSession.hadToolFailure = true;
+}
+function getCurrentMcpClientMetadata() {
+	return currentSession?.metadata ?? {
+		name: UNKNOWN_METADATA,
+		version: UNKNOWN_METADATA,
+		protocolVersion: UNKNOWN_METADATA
+	};
+}
+function recordMcpSessionTermination(category) {
+	const session = currentSession;
+	const durationMs = session ? Math.max(0, Date.now() - session.startedAt) : 0;
+	const attributes = {
+		...metadataAttributes(session?.metadata ?? {
+			name: UNKNOWN_METADATA,
+			version: UNKNOWN_METADATA,
+			protocolVersion: UNKNOWN_METADATA
+		}),
+		termination_category: category,
+		session_duration_bucket: durationBucket(durationMs),
+		tool_calls_bucket: bucketCount(session?.toolCalls ?? 0)
+	};
+	sessionEnded.add(1, attributes);
+	currentSession = void 0;
+}
+function resolveSessionTerminationCategory(shutdownSucceeded) {
+	if (!shutdownSucceeded) return "unknown";
+	return currentSession?.hadToolFailure ? "tool_failure" : "clean";
+}
+//#endregion
 //#region src/utils/telemetry-wrapper.ts
-/** Whitelist of safe argument keys that can be logged without exposing PII. */
-const ARGUMENT_WHITELIST = /* @__PURE__ */ new Set([
-	"page",
-	"pageSize",
-	"since",
-	"workoutId",
-	"routineId",
-	"folderId",
-	"exerciseTemplateId",
-	"date",
-	"startDate",
-	"endDate",
-	"updatedSince",
-	"includeCustom",
-	"limit",
-	"offset",
-	"refresh",
-	"query",
-	"primaryMuscleGroup"
-]);
+const STRUCTURAL_ARGUMENT_KEYS = {
+	page: true,
+	pageSize: true,
+	since: true,
+	workoutId: true,
+	routineId: true,
+	folderId: true,
+	exerciseTemplateId: true,
+	date: true,
+	startDate: true,
+	endDate: true,
+	updatedSince: true,
+	includeCustom: true,
+	limit: true,
+	offset: true,
+	refresh: true,
+	query: true,
+	primaryMuscleGroup: true
+};
+const BUCKETED_ARGUMENT_KEYS = {
+	page: true,
+	pageSize: true,
+	limit: true,
+	offset: true
+};
+const PRESENCE_ONLY_ARGUMENT_KEYS = {
+	since: true,
+	workoutId: true,
+	routineId: true,
+	folderId: true,
+	exerciseTemplateId: true,
+	date: true,
+	startDate: true,
+	endDate: true,
+	updatedSince: true,
+	query: true,
+	primaryMuscleGroup: true
+};
 function extractSafeArgs(args) {
 	const attributes = {};
+	const keys = [];
 	for (const [key, value] of Object.entries(args)) {
-		if (!ARGUMENT_WHITELIST.has(key)) continue;
-		if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") continue;
-		attributes[`mcp.tool.args.${key}`] = key === "query" && typeof value === "string" && value.length > 100 ? `${value.slice(0, 100)}...` : value;
+		if (STRUCTURAL_ARGUMENT_KEYS[key] !== true) continue;
+		keys.push(key);
+		if (PRESENCE_ONLY_ARGUMENT_KEYS[key] === true) {
+			if (value !== void 0 && value !== null) attributes[`mcp.tool.args.${key}.present`] = true;
+			continue;
+		}
+		if (BUCKETED_ARGUMENT_KEYS[key] === true && typeof value === "number") {
+			attributes[`mcp.tool.args.${key}.bucket`] = bucketCount(value);
+			continue;
+		}
+		if (typeof value === "boolean") attributes[`mcp.tool.args.${key}`] = value;
 	}
+	return {
+		attributes,
+		keys
+	};
+}
+function setWorkflowAttributes(span, workflow) {
+	if (!workflow) return;
+	span.setAttribute("workflow.name", workflow.name);
+	span.setAttribute("workflow.cache_status", workflow.cacheStatus);
+	span.setAttribute("workflow.items_scanned", workflow.itemsScanned);
+	const allowedResources = {
+		workouts: true,
+		bodyMeasurements: true,
+		routines: true
+	};
+	for (const [resource, pageCount] of Object.entries(workflow.pagination ?? {})) if (allowedResources[resource] === true && Number.isSafeInteger(pageCount) && pageCount >= 0) span.setAttribute(`workflow.pagination.${resource}.pages`, pageCount);
+}
+function setResultAttributes(span, result) {
+	span.setAttribute("mcp.tool.result.is_error", Boolean(result.isError));
+	span.setAttribute("mcp.tool.result.has_structured_content", "structuredContent" in result && result.structuredContent !== void 0);
+	if (Array.isArray(result.content)) span.setAttribute("mcp.tool.result.content_count", result.content.length);
+	const telemetry = getResultTelemetry(result);
+	if (!telemetry) return;
+	if (telemetry.itemCountBucket) span.setAttribute("mcp.tool.result.item_count_bucket", telemetry.itemCountBucket);
+	if (telemetry.exerciseCountBucket) span.setAttribute("mcp.tool.result.exercise_count_bucket", telemetry.exerciseCountBucket);
+	if (telemetry.setCountBucket) span.setAttribute("mcp.tool.result.set_count_bucket", telemetry.setCountBucket);
+	setWorkflowAttributes(span, telemetry.workflow);
+}
+function resultMetricAttributes(result) {
+	const attributes = { "mcp.tool.result.has_structured_content": "structuredContent" in result && result.structuredContent !== void 0 };
+	const telemetry = getResultTelemetry(result);
+	if (!telemetry) return attributes;
+	if (telemetry.itemCountBucket) attributes["mcp.tool.result.item_count_bucket"] = telemetry.itemCountBucket;
+	if (telemetry.exerciseCountBucket) attributes["mcp.tool.result.exercise_count_bucket"] = telemetry.exerciseCountBucket;
+	if (telemetry.setCountBucket) attributes["mcp.tool.result.set_count_bucket"] = telemetry.setCountBucket;
 	return attributes;
 }
-function isRecord(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
+function taxonomyAttributes(metadata) {
+	return metadata ? {
+		"hevy.feature": metadata.feature,
+		"mcp.tool.kind": metadata.kind,
+		"mcp.tool.operation": metadata.operation
+	} : {};
 }
-function getWorkflowTelemetry(result) {
-	const structuredContent = result.structuredContent;
-	if (!isRecord(structuredContent)) return null;
-	const workflow = structuredContent.workflow;
-	if (!isRecord(workflow)) return null;
-	const name = workflow.name;
-	const paginationValue = workflow.pagination;
-	const cacheStatus = workflow.cacheStatus;
-	const itemsScanned = workflow.itemsScanned;
-	if (typeof name !== "string" || !isRecord(paginationValue) || typeof cacheStatus !== "string" || typeof itemsScanned !== "number" || !Number.isSafeInteger(itemsScanned) || itemsScanned < 0) return null;
-	const pagination = {};
-	for (const [key, value] of Object.entries(paginationValue)) if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) pagination[key] = value;
+function metricAttributes(context, metadata, clientAttributes) {
 	return {
-		name,
-		pagination,
-		cacheStatus,
-		itemsScanned
+		tool_name: context,
+		...taxonomyAttributes(metadata),
+		...clientAttributes
 	};
 }
 /**
-* Wrap an MCP tool handler with its existing OpenTelemetry span and metrics.
+* Privacy contract: this wrapper records only bounded tool taxonomy, structural
+* argument presence/buckets, safe result-shape metadata, and allowlisted error
+* diagnostics. It MUST NOT read or emit prompt text, tool arguments, result
+* bodies, identifiers, dates, titles, notes, descriptions, or measurements.
 */
-function withTelemetry(fn, context) {
+function withTelemetry(fn, context, metadata) {
 	return async (rawArgs) => {
 		const args = rawArgs ?? {};
 		if (isDebugEnabled()) debugLog("tool_invocation", {
 			tool: context,
 			params: redactToolArgs(args)
 		});
+		const { attributes: safeArgs, keys: safeArgumentKeys } = extractSafeArgs(args);
+		const clientAttributes = recordMcpToolInvocation();
+		let resultMetrics = {};
+		const clientMetadata = getCurrentMcpClientMetadata();
+		const metrics = metricAttributes(context, metadata, clientAttributes);
 		const argumentKeyCount = Object.keys(args).length;
 		const startTime = Date.now();
-		let isError = false;
-		toolInvocations.add(1, { tool_name: context });
-		const safeArgs = extractSafeArgs(args);
-		const whitelistedKeys = Object.keys(safeArgs).map((key) => key.replace("mcp.tool.args.", ""));
+		let outcome = "success";
+		toolInvocations.add(1, metrics);
 		return tracer.startActiveSpan(`mcp.tool.${context}`, { attributes: {
 			"mcp.tool.name": context,
-			"workflow.name": context,
-			"mcp.tool.args.key_count": argumentKeyCount,
-			"mcp.tool.args.keys": whitelistedKeys.join(","),
+			...taxonomyAttributes(metadata),
+			"mcp.client.name": clientMetadata.name,
+			"mcp.client.version": clientMetadata.version,
+			"mcp.protocol.version": clientMetadata.protocolVersion,
+			"mcp.transport": "stdio",
+			"mcp.tool.args.key_count_bucket": bucketCount(argumentKeyCount),
+			"mcp.tool.args.keys": safeArgumentKeys.join(","),
 			...safeArgs
 		} }, async (span) => {
 			try {
 				const result = await fn(args);
-				isError = Boolean(result.isError);
-				span.setStatus({ code: isError ? SpanStatusCode.ERROR : SpanStatusCode.OK });
-				span.setAttribute("mcp.tool.result.is_error", isError);
-				if (result.content) {
-					span.setAttribute("mcp.tool.result.content_count", result.content.length);
-					const textLength = result.content.reduce((sum, item) => sum + (item.text?.length ?? 0), 0);
-					span.setAttribute("mcp.tool.result.text_length", textLength);
-				}
-				const workflow = getWorkflowTelemetry(result);
-				if (workflow) {
-					span.setAttribute("workflow.name", workflow.name);
-					span.setAttribute("workflow.cache_status", workflow.cacheStatus);
-					span.setAttribute("workflow.items_scanned", workflow.itemsScanned);
-					for (const [resource, pageCount] of Object.entries(workflow.pagination)) span.setAttribute(`workflow.pagination.${resource}.pages`, pageCount);
-				}
+				const isError = Boolean(result.isError);
+				if (isError) try {
+					recordMcpToolFailure();
+				} catch {}
+				outcome = isError ? "returned_error" : "success";
+				try {
+					span.setStatus({ code: isError ? SpanStatusCode.ERROR : SpanStatusCode.OK });
+					setResultAttributes(span, result);
+					resultMetrics = resultMetricAttributes(result);
+					span.setAttribute("mcp.tool.outcome", outcome);
+					toolOutcomes.add(1, {
+						...metrics,
+						outcome
+					});
+				} catch {}
 				return result;
 			} catch (error) {
-				isError = true;
+				outcome = "thrown_error";
+				recordMcpToolFailure();
 				span.setStatus({ code: SpanStatusCode.ERROR });
+				span.setAttribute("mcp.tool.outcome", outcome);
 				const policy = resolveErrorPolicy(error, "");
 				const { diagnostic } = policy;
 				span.addEvent("mcp.tool.failure", {
@@ -3835,14 +4210,20 @@ function withTelemetry(fn, context) {
 				const errorType = policy.type;
 				span.setAttribute("error.type", errorType);
 				toolErrors.add(1, {
-					tool_name: context,
+					...metrics,
 					error_type: errorType
 				});
+				toolOutcomes.add(1, {
+					...metrics,
+					outcome
+				});
 				throw error;
 			} finally {
 				toolDuration.record(Date.now() - startTime, {
-					tool_name: context,
-					is_error: String(isError)
+					...metrics,
+					...resultMetrics,
+					is_error: String(outcome !== "success"),
+					outcome
 				});
 				span.end();
 			}
@@ -3851,18 +4232,29 @@ function withTelemetry(fn, context) {
 }
 //#endregion
 //#region src/utils/observability-wrapper.ts
-/**
-* Wrap an MCP tool handler with telemetry inside error response handling.
-*/
-function withObservability(fn, context) {
-	return withErrorHandling(withTelemetry(fn, context), context, (error, _toolContext, argumentKeyCount) => {
+/** Wrap an MCP tool handler with telemetry inside error response handling. */
+function withObservability(fn, context, metadata) {
+	return withErrorHandling(withTelemetry(fn, context, metadata), context, (error, toolContext, argumentKeyCount) => {
 		const { diagnostic } = resolveErrorPolicy(error, "");
 		Sentry.withScope((scope) => {
+			scope.setTag("mcp.tool.context", toolContext);
 			scope.setTag("error.category", diagnostic.category);
 			if (diagnostic.code) scope.setTag("error.code", diagnostic.code);
 			if (diagnostic.status !== void 0) scope.setTag("http.status_code", String(diagnostic.status));
-			scope.setContext("mcpTool", { argumentKeyCount });
+			if (diagnostic.endpoint) scope.setTag("hevy.api.endpoint", diagnostic.endpoint);
+			scope.setContext("mcpTool", {
+				context: toolContext,
+				argumentKeyCountBucket: bucketCount(argumentKeyCount)
+			});
 			scope.setContext("safeError", { ...diagnostic });
+			scope.setFingerprint([
+				"mcp-tool-failure",
+				toolContext,
+				diagnostic.category,
+				diagnostic.code ?? "none",
+				String(diagnostic.status ?? "none"),
+				diagnostic.endpoint ?? "none"
+			]);
 			Sentry.captureMessage("MCP tool failure", "error");
 		});
 	});
@@ -3872,6 +4264,18 @@ function withObservability(fn, context) {
 const UTF8_BOM = "";
 /** Maximum escaped characters included in a malformed stdin shape preview. */
 const STDIN_PARSE_SHAPE_PREVIEW_MAX_LENGTH = 200;
+const SAFE_MCP_METHODS = {
+	initialize: true,
+	"notifications/initialized": true,
+	"notifications/cancelled": true,
+	ping: true,
+	"tools/call": true,
+	"tools/list": true,
+	"resources/read": true,
+	"resources/list": true,
+	"prompts/get": true,
+	"prompts/list": true
+};
 const REDACTED_CONTENT_MARKER = "[REDACTED]";
 /**
 * Adapter boundary around MCP SDK stdio internals.
@@ -3999,7 +4403,16 @@ function deserializeMessageWithObservability(line, chunkSnapshot) {
 		try {
 			const message = deserializeMessage(normalizedLine);
 			span.setStatus({ code: SpanStatusCode.OK });
-			if (message && typeof message === "object" && "method" in message) span.setAttribute("mcp.method", String(message.method));
+			if (message && typeof message === "object" && "method" in message) {
+				const method = message.method;
+				if (typeof method === "string" && SAFE_MCP_METHODS[method] === true) span.setAttribute("mcp.method", method);
+				if (method === "initialize") {
+					const client = recordMcpSessionStart(message);
+					span.setAttribute("mcp.client.name", client.name);
+					span.setAttribute("mcp.client.version", client.version);
+					span.setAttribute("mcp.protocol.version", client.protocolVersion);
+				}
+			}
 			return message;
 		} catch (error) {
 			const diagnostic = createSafeErrorDiagnostic(error);
@@ -4263,7 +4676,10 @@ function buildServer(apiKey) {
 				apiKey,
 				clientOptions: createNodeHevyClientOptions(),
 				wrapHandler: withObservability,
-				wrapServer: (baseServer) => Sentry.wrapMcpServerWithSentry(baseServer),
+				wrapServer: (baseServer) => Sentry.wrapMcpServerWithSentry(baseServer, {
+					recordInputs: false,
+					recordOutputs: false
+				}),
 				onToolsRegistered: (count) => span.setAttribute("mcp.tools.count", count)
 			});
 			console.error("Hevy client initialized with API key");
@@ -4302,6 +4718,7 @@ async function runServer() {
 		setCurrentUserHash(initialUserHash);
 		Sentry.setUser({ id: initialUserHash });
 	}
+	let connectAttempted = false;
 	await tracer.startActiveSpan("mcp.server.run", { attributes: { "mcp.transport": "stdio" } }, async (span) => {
 		try {
 			const apiKey = parseConfig(process.env).apiKey;
@@ -4309,6 +4726,7 @@ async function runServer() {
 			const server = await createServer({ config: { apiKey } });
 			console.error("Starting MCP server in stdio mode");
 			const transport = createInstrumentedStdioTransport(new StdioServerTransport());
+			connectAttempted = true;
 			await tracer.startActiveSpan("mcp.server.connect", { attributes: { "mcp.transport": "stdio" } }, async (connectSpan) => {
 				try {
 					await server.connect(transport);
@@ -4324,9 +4742,16 @@ async function runServer() {
 				packageName: name$1,
 				currentVersion: version$1
 			});
-			installGracefulShutdown({ target: server });
+			installGracefulShutdown({
+				target: server,
+				onComplete: async (succeeded) => {
+					recordMcpSessionTermination(resolveSessionTerminationCategory(succeeded));
+					await flushTelemetry();
+				}
+			});
 			span.setStatus({ code: SpanStatusCode.OK });
 		} catch (e) {
+			recordMcpSessionTermination(connectAttempted ? "connect_failure" : "startup_failure");
 			span.setStatus({ code: SpanStatusCode.ERROR });
 			throw e;
 		} finally {
@@ -4335,6 +4760,6 @@ async function runServer() {
 	});
 }
 //#endregion
-export { createSafeErrorDiagnostic as i, createServer as n, runServer as r, configSchema as t };
+export { flushTelemetry as a, createSafeErrorDiagnostic as i, createServer as n, runServer as r, configSchema as t };
 
-//# sourceMappingURL=src-B_mNqS1X.mjs.map
+//# sourceMappingURL=src-Ch2aS5wP.mjs.map