fix: keep MCP stdio clean on routine update errors (#330)

Co-authored-by: CharlieHelps <charlie@charlielabs.ai>

Author: charliecreates[bot]

src/tools/routines.test.ts

@@ -579,6 +579,69 @@ describe("registerRoutineTools", () => {
 		expect(response.content).toHaveLength(1);
 	});
 
+	it("update-routine omits rep_range when repRange does not contain values", async () => {
+		const { server, tool } = createMockServer();
+		const routine: Routine = {
+			id: "updated-routine",
+			title: "Updated Routine",
+			folder_id: null,
+			created_at: "2025-03-26T19:00:00Z",
+			updated_at: "2025-03-26T19:30:00Z",
+			exercises: [],
+		};
+		const updateRoutineMock = vi.fn().mockResolvedValue(routine);
+		const hevyClient: HevyClient = {
+			updateRoutine: updateRoutineMock,
+		} as unknown as HevyClient;
+
+		registerRoutineTools(server, hevyClient);
+		const { handler } = getToolRegistration(tool, "update-routine");
+
+		await handler({
+			routineId: "routine-123",
+			title: "Updated Routine",
+			exercises: [
+				{
+					exerciseTemplateId: "template-id",
+					supersetId: null,
+					restSeconds: 90,
+					sets: [
+						{
+							type: "normal" as const,
+							weightKg: 100,
+							reps: 10,
+							repRange: { start: null, end: null },
+						},
+					],
+				},
+			],
+		} as Record<string, unknown>);
+
+		expect(updateRoutineMock).toHaveBeenCalledWith(
+			"routine-123",
+			expect.objectContaining({
+				routine: expect.objectContaining({
+					exercises: [
+						expect.objectContaining({
+							sets: [expect.objectContaining({ reps: 10 })],
+						}),
+					],
+				}),
+			}),
+		);
+
+		const updatePayload = updateRoutineMock.mock.calls[0]?.[1] as {
+			routine: {
+				exercises: Array<{
+					sets: Array<Record<string, unknown>>;
+				}>;
+			};
+		};
+		expect(updatePayload.routine.exercises[0]?.sets[0]).not.toHaveProperty(
+			"rep_range",
+		);
+	});
+
 	it("update-routine includes a rep range display warning when repRange is provided", async () => {
 		const { server, tool } = createMockServer();
 		const routine: Routine = {
@@ -685,7 +748,6 @@ describe("registerRoutineTools", () => {
 								distance_meters: null,
 								duration_seconds: null,
 								custom_metric: null,
-								rep_range: null,
 							},
 						],
 					},

src/tools/routines.ts

@@ -375,7 +375,7 @@ export function registerRoutineTools(
 									distance_meters: set.distance ?? set.distanceMeters ?? null,
 									duration_seconds: set.duration ?? set.durationSeconds ?? null,
 									custom_metric: set.customMetric ?? null,
-									rep_range: repRange,
+									...(repRange ? { rep_range: repRange } : {}),
 								};
 							});
 

src/utils/error-handler.test.ts

@@ -66,7 +66,11 @@ describe("Error Handler", () => {
 			const response = createErrorResponse(errorWithCode);
 
 			expect(response.content[0].text).toBe("Error: Error with code");
-			expect(console.debug).toHaveBeenCalledWith("Error code: ERR_TEST_CODE");
+			expect(console.debug).not.toHaveBeenCalled();
+			expect(console.error).toHaveBeenCalledWith(
+				expect.stringContaining("Code: ERR_TEST_CODE"),
+				errorWithCode,
+			);
 		});
 
 		it("classifies network-related errors as NETWORK_ERROR", () => {

src/utils/error-handler.ts

@@ -70,16 +70,15 @@ export function createErrorResponse(
 	// Determine error type based on error characteristics
 	const errorType = determineErrorType(error, errorMessage);
 
-	// Include error code in logs if available
-	if (errorCode) {
-		console.debug(`Error code: ${errorCode}`);
-	}
-
 	const contextPrefix = context ? `[${context}] ` : "";
 	const formattedMessage = `${contextPrefix}Error: ${errorMessage}`;
+	const errorCodeSuffix = errorCode ? `, Code: ${errorCode}` : "";
 
 	// Log the error for server-side debugging with type information
-	console.error(`${formattedMessage} (Type: ${errorType})`, error);
+	console.error(
+		`${formattedMessage} (Type: ${errorType}${errorCodeSuffix})`,
+		error,
+	);
 
 	return {
 		content: [