@einlogic/mcp-fitbit 1.0.1 → 2.1.0

package/build/data-points.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { registerTool, CommonSchemas, listDataPoints, handleGoogleHealthCall, dataPointsPath, } from './utils.js';
+import { DATA_TYPES } from './config.js';
+const dataTypeSchema = z
+    .enum(DATA_TYPES)
+    .describe('Google Health data type (kebab-case), e.g. "steps", "body-fat"');
+const filterSchema = z
+    .string()
+    .optional()
+    .describe('Optional filter, e.g. steps.interval.civil_start_time >= "2026-03-04T00:00:00". Data type names are snake_case inside filters');
+/**
+ * Registers generic data point tools (escape hatches for any data type).
+ * @param server The McpServer instance.
+ * @param getAccessTokenFn Function to retrieve the current access token.
+ */
+export function registerDataPointTools(server, getAccessTokenFn) {
+    registerTool(server, {
+        name: 'list_data_points',
+        description: 'Get the raw JSON response for data points of any Google Health data type (GET users/me/dataTypes/{type}/dataPoints), with an optional raw filter. Use this for data types not covered by the named tools.',
+        parametersSchema: {
+            dataType: dataTypeSchema,
+            filter: filterSchema,
+            pageSize: CommonSchemas.pageSize,
+            pageToken: CommonSchemas.pageToken,
+        },
+        handler: async ({ dataType, filter, pageSize, pageToken, }) => listDataPoints(dataType, getAccessTokenFn, { filter, pageSize, pageToken }, `data type '${dataType}'`),
+    });
+    registerTool(server, {
+        name: 'reconcile_data_points',
+        description: 'Get the raw JSON response for reconciled data points of any Google Health data type (GET .../dataPoints:reconcile). Reconciling removes overlapping intervals across devices and sync batches, so use it for timelines and durations.',
+        parametersSchema: {
+            dataType: dataTypeSchema,
+            filter: filterSchema,
+            dataSourceFamily: CommonSchemas.dataSourceFamily,
+            pageSize: CommonSchemas.pageSize,
+            pageToken: CommonSchemas.pageToken,
+        },
+        handler: async ({ dataType, filter, dataSourceFamily, pageSize, pageToken, }) => handleGoogleHealthCall(dataPointsPath(dataType, ':reconcile'), getAccessTokenFn, {
+            query: { filter, dataSourceFamily, pageSize, pageToken },
+            successDataExtractor: (data) => data.dataPoints,
+            errorContext: `reconciled data type '${dataType}'`,
+        }),
+    });
+}

package/build/heart-rate.js

@@ -1,106 +1,36 @@
-import { z } from 'zod';
-import { makeFitbitRequest } from './utils.js';
-const FITBIT_API_BASE = 'https://api.fitbit.com/1';
-// --- Tool Registration ---
+import { registerTool, CommonSchemas, listDataPoints, dailyRollUp, buildRangeFilter, } from './utils.js';
+import { VALIDATION_MESSAGES } from './config.js';
 /**
- * Registers Fitbit heart rate tools with the MCP server.
+ * Registers heart rate tools with the MCP server.
  * @param server The McpServer instance.
  * @param getAccessTokenFn Function to retrieve the current access token.
  */
 export function registerHeartRateTools(server, getAccessTokenFn) {
-    // --- Heart Rate by Date/Period Tool ---
-    const periodToolName = 'get_heart_rate';
-    const periodDescription = "Get the raw JSON response for heart rate data from Fitbit for a specified period ending today or on a specific date. Requires a 'period' parameter such as '1d', '7d', '30d', '1w', '1m' and optionally accepts 'date' parameter.";
-    const periodParametersSchemaShape = {
-        period: z
-            .enum(['1d', '7d', '30d', '1w', '1m'])
-            .describe('The time period for which to retrieve heart rate data.'),
-        date: z
-            .string()
-            .regex(/^\d{4}-\d{2}-\d{2}$|^today$/, "Date must be in YYYY-MM-DD format or 'today'.")
-            .optional()
-            .describe("The date for which to retrieve heart rate data (YYYY-MM-DD or 'today'). Defaults to 'today'."),
-    };
-    server.tool(periodToolName, periodDescription, periodParametersSchemaShape, async ({ period, date = 'today', }) => {
-        // Construct the endpoint dynamically
-        const endpoint = `activities/heart/date/${date}/${period}.json`;
-        const heartRateData = await makeFitbitRequest(endpoint, getAccessTokenFn, FITBIT_API_BASE);
-        // Handle API call failure
-        if (!heartRateData) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Failed to retrieve heart rate data from Fitbit API for date '${date}' and period '${period}'. Check token and permissions.`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-        // Handle no data found for the period
-        const heartRateEntries = heartRateData['activities-heart'] || [];
-        if (heartRateEntries.length === 0) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `No heart rate data found for date '${date}' and period '${period}'.`,
-                    },
-                ],
-            };
-        }
-        // Return successful response with raw JSON
-        const rawJsonResponse = JSON.stringify(heartRateData, null, 2);
-        return {
-            content: [{ type: 'text', text: rawJsonResponse }],
-        };
+    // Raw heart rate samples
+    registerTool(server, {
+        name: 'get_heart_rate',
+        description: 'Get the raw JSON response for heart rate samples from the Google Health API (data type "heart-rate"), filtered by sample time. Requires a start timestamp (RFC 3339); the end is optional and exclusive. Supports pagination via pageToken.',
+        parametersSchema: {
+            startTime: CommonSchemas.physicalStartTime,
+            endTime: CommonSchemas.physicalEndTime,
+            pageSize: CommonSchemas.pageSize,
+            pageToken: CommonSchemas.pageToken,
+        },
+        handler: async ({ startTime, endTime, pageSize, pageToken, }) => listDataPoints('heart-rate', getAccessTokenFn, {
+            filter: buildRangeFilter('heart_rate.sample_time.physical_time', startTime, endTime),
+            pageSize,
+            pageToken,
+        }, `heart rate from '${startTime}'${endTime ? ` to '${endTime}'` : ''}`),
     });
-    // --- Heart Rate by Date Range Tool ---
-    const rangeToolName = 'get_heart_rate_by_date_range';
-    const rangeDescription = "Get the raw JSON response for heart rate data from Fitbit for a specific date range. Requires 'startDate' and 'endDate' parameters in 'YYYY-MM-DD' format. Note: The API enforces a maximum range of 1 year.";
-    const rangeParametersSchemaShape = {
-        startDate: z
-            .string()
-            .regex(/^\d{4}-\d{2}-\d{2}$/, 'Start date must be in YYYY-MM-DD format.')
-            .describe('The start date for which to retrieve heart rate data (YYYY-MM-DD).'),
-        endDate: z
-            .string()
-            .regex(/^\d{4}-\d{2}-\d{2}$/, 'End date must be in YYYY-MM-DD format.')
-            .describe('The end date for which to retrieve heart rate data (YYYY-MM-DD).'),
-    };
-    server.tool(rangeToolName, rangeDescription, rangeParametersSchemaShape, async ({ startDate, endDate, }) => {
-        // Construct the endpoint dynamically
-        const endpoint = `activities/heart/date/${startDate}/${endDate}.json`;
-        // Make the request
-        const heartRateData = await makeFitbitRequest(endpoint, getAccessTokenFn, FITBIT_API_BASE);
-        // Handle API call failure
-        if (!heartRateData) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Failed to retrieve heart rate data from Fitbit API for the date range '${startDate}' to '${endDate}'. Check token, permissions, date format, and ensure the range is 1 year or less.`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-        // Handle no data found
-        const heartRateEntries = heartRateData['activities-heart'] || [];
-        if (heartRateEntries.length === 0) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `No heart rate data found for the date range '${startDate}' to '${endDate}'.`,
-                    },
-                ],
-            };
-        }
-        // Return successful response
-        const rawJsonResponse = JSON.stringify(heartRateData, null, 2);
-        return {
-            content: [{ type: 'text', text: rawJsonResponse }],
-        };
+    // Daily heart rate roll-up
+    registerTool(server, {
+        name: 'get_heart_rate_by_date_range',
+        description: `Get the raw JSON response for daily heart rate roll-ups from the Google Health API (dailyRollUp of "heart-rate") over a civil date range. startDate is inclusive, endDate is exclusive. ${VALIDATION_MESSAGES.MAX_RANGE_14_DAYS}.`,
+        parametersSchema: {
+            startDate: CommonSchemas.startDate,
+            endDate: CommonSchemas.endDate,
+            dataSourceFamily: CommonSchemas.dataSourceFamily,
+        },
+        handler: async ({ startDate, endDate, dataSourceFamily, }) => dailyRollUp('heart-rate', getAccessTokenFn, { startDate, endDate, dataSourceFamily }, `heart rate from ${startDate} to ${endDate}`),
     });
 }

package/build/hrv.js

@@ -1,35 +1,35 @@
-import { registerTool, CommonSchemas, handleFitbitApiCall, } from './utils.js';
+import { registerTool, CommonSchemas, listDataPoints, buildRangeFilter, nextDate, } from './utils.js';
+export const HRV_DATA_TYPE = 'daily-heart-rate-variability';
+export const HRV_DATE_FIELD = 'daily_heart_rate_variability.date';
 /**
  * Registers Heart Rate Variability (HRV) tools with the MCP server.
  * @param server The McpServer instance.
  * @param getAccessTokenFn Function to retrieve the current access token.
  */
 export function registerHrvTools(server, getAccessTokenFn) {
+    // Tool 1: Get daily HRV for a single date
     registerTool(server, {
         name: 'get_hrv',
-        description: 'Get the raw JSON response for Heart Rate Variability (HRV) summary data from Fitbit for a single date. Returns daily RMSSD and deep sleep RMSSD values.',
+        description: 'Get the raw JSON response for daily Heart Rate Variability (HRV) from the Google Health API (data type "daily-heart-rate-variability") for a single date.',
         parametersSchema: {
             date: CommonSchemas.date,
         },
-        handler: async ({ date }) => {
-            const endpoint = `hrv/date/${date}.json`;
-            return handleFitbitApiCall(endpoint, { date }, getAccessTokenFn, {
-                errorContext: `HRV data for ${date}`,
-            });
-        },
+        handler: async ({ date }) => listDataPoints(HRV_DATA_TYPE, getAccessTokenFn, { filter: buildRangeFilter(HRV_DATE_FIELD, date, nextDate(date)) }, `HRV data for ${date}`),
     });
+    // Tool 2: Get daily HRV over a date range
     registerTool(server, {
         name: 'get_hrv_by_date_range',
-        description: 'Get the raw JSON response for Heart Rate Variability (HRV) summary data from Fitbit over a date range (max 30 days). Returns daily RMSSD and deep sleep RMSSD values for each day.',
+        description: 'Get the raw JSON response for daily Heart Rate Variability (HRV) from the Google Health API (data type "daily-heart-rate-variability") over a date range. startDate is inclusive, endDate is exclusive. Supports pagination via pageToken.',
         parametersSchema: {
             startDate: CommonSchemas.startDate,
             endDate: CommonSchemas.endDate,
+            pageSize: CommonSchemas.pageSize,
+            pageToken: CommonSchemas.pageToken,
         },
-        handler: async ({ startDate, endDate }) => {
-            const endpoint = `hrv/date/${startDate}/${endDate}.json`;
-            return handleFitbitApiCall(endpoint, { startDate, endDate }, getAccessTokenFn, {
-                errorContext: `HRV data from ${startDate} to ${endDate}`,
-            });
-        },
+        handler: async ({ startDate, endDate, pageSize, pageToken, }) => listDataPoints(HRV_DATA_TYPE, getAccessTokenFn, {
+            filter: buildRangeFilter(HRV_DATE_FIELD, startDate, endDate),
+            pageSize,
+            pageToken,
+        }, `HRV data from ${startDate} to ${endDate}`),
     });
 }

package/build/index.js

@@ -5,7 +5,7 @@ import dotenv from 'dotenv';
 import path from 'path';
 import { fileURLToPath } from 'url';
 // Import authentication functions
-import { initializeAuth, startAuthorizationFlow, getAccessToken, } from './auth.js';
+import { initializeAuth, startAuthorizationFlow, getAccessToken, reauthenticate, } from './auth.js';
 // Import tool registration function(s)
 import { registerWeightTool } from './weight.js';
 import { registerSleepTool } from './sleep.js';
@@ -14,10 +14,14 @@ import { registerActivitiesTool } from './activities.js';
 import { registerHeartRateTools } from './heart-rate.js';
 import { registerNutritionTools } from './nutrition.js';
 import { registerDailyActivityTool } from './daily-activity.js';
-import { registerActivityGoalsTool } from './activity-goals.js';
 import { registerActivityTimeSeriesTool } from './activity-timeseries.js';
 import { registerAzmTimeSeriesTool } from './azm-timeseries.js';
 import { registerHrvTools } from './hrv.js';
+import { registerAccountTools } from './account.js';
+import { registerAuthTools } from './auth-tools.js';
+import { registerDataPointTools } from './data-points.js';
+import { registerCompatTools } from './compat/tools.js';
+import { resolveClientCredentials, resolveOutputMode } from './config.js';
 // Import utilities
 import './utils.js';
 // Calculate the directory name of the current module (build/index.js)
@@ -29,20 +33,22 @@ const envPath = path.resolve(__dirname, '..', '.env');
 dotenv.config({ path: envPath });
 // Validate required environment variables
 function validateEnvironment() {
+    // GOOGLE_HEALTH_* is preferred; legacy FITBIT_* names are accepted as a fallback
+    const credentials = resolveClientCredentials();
     const requiredVars = {
-        FITBIT_CLIENT_ID: process.env.FITBIT_CLIENT_ID,
-        FITBIT_CLIENT_SECRET: process.env.FITBIT_CLIENT_SECRET,
+        GOOGLE_HEALTH_CLIENT_ID: credentials.id,
+        GOOGLE_HEALTH_CLIENT_SECRET: credentials.secret,
     };
     const missingVars = Object.entries(requiredVars)
         .filter(([, value]) => !value)
         .map(([key]) => key);
     if (missingVars.length > 0) {
         console.error('Missing required environment variables:');
-        missingVars.forEach(varName => {
+        missingVars.forEach((varName) => {
             console.error(`   - ${varName}`);
         });
         console.error(`Please create a .env file at: ${envPath}`);
-        console.error('See README.md for details on getting Fitbit API credentials.');
+        console.error('See README.md for details on getting Google Health API credentials.');
         process.exit(1);
     }
 }
@@ -52,25 +58,35 @@ validateEnvironment();
 console.error('✅ Environment variables loaded successfully');
 // Create the main MCP server instance
 const server = new McpServer({
-    name: 'fitbit',
-    version: '1.0.0',
+    name: 'google-health',
+    version: '2.1.0',
     capabilities: {
         resources: {},
         tools: {}, // Tools are registered dynamically below
     },
 });
-// Register available tools with the MCP server
-registerWeightTool(server, getAccessToken);
-registerSleepTool(server, getAccessToken);
+// Register available tools with the MCP server.
+// GOOGLE_HEALTH_OUTPUT_MODE=fitbit swaps the tools that overlap the legacy Fitbit tools for
+// Fitbit-shaped versions; everything else stays a 1:1 Google Health proxy.
+if (resolveOutputMode() === 'fitbit') {
+    console.error('Output mode: fitbit (legacy Fitbit tool names, parameters, shapes and units)');
+    registerCompatTools(server, getAccessToken);
+}
+else {
+    registerWeightTool(server, getAccessToken);
+    registerSleepTool(server, getAccessToken);
+    registerHeartRateTools(server, getAccessToken);
+    registerNutritionTools(server, getAccessToken);
+    registerDailyActivityTool(server, getAccessToken);
+    registerActivityTimeSeriesTool(server, getAccessToken);
+    registerAzmTimeSeriesTool(server, getAccessToken);
+    registerHrvTools(server, getAccessToken);
+}
 registerProfileTool(server, getAccessToken);
 registerActivitiesTool(server, getAccessToken);
-registerHeartRateTools(server, getAccessToken);
-registerNutritionTools(server, getAccessToken);
-registerDailyActivityTool(server, getAccessToken);
-registerActivityGoalsTool(server, getAccessToken);
-registerActivityTimeSeriesTool(server, getAccessToken);
-registerAzmTimeSeriesTool(server, getAccessToken);
-registerHrvTools(server, getAccessToken);
+registerAccountTools(server, getAccessToken);
+registerAuthTools(server, reauthenticate);
+registerDataPointTools(server, getAccessToken);
 // --- Main Application Entry Point ---
 async function main() {
     // Initialize the authentication module (e.g., load persisted token)
@@ -80,12 +96,12 @@ async function main() {
     try {
         // Connect the MCP server to the transport
         await server.connect(transport);
-        console.error('Fitbit MCP Server connected via stdio.');
+        console.error('Google Health MCP Server connected via stdio.');
         // Check if an access token is available after connection
         // If not, initiate the OAuth2 authorization flow
         const token = await getAccessToken();
         if (!token) {
-            console.error('No access token found. Starting Fitbit authorization flow...');
+            console.error('No access token found. Starting Google Health authorization flow...');
             startAuthorizationFlow(); // Start flow in background, do not await
         }
         else {

package/build/nutrition.js

@@ -1,162 +1,51 @@
 import { z } from 'zod';
-import { makeFitbitRequest } from './utils.js';
-const FITBIT_API_BASE = 'https://api.fitbit.com/1';
-// --- Tool Registration ---
+import { registerTool, CommonSchemas, listDataPoints, dailyRollUp, buildRangeFilter, nextDate, } from './utils.js';
+// Nutrition-related data types that support roll-ups
+export const NUTRITION_DATA_TYPES = ['nutrition-log', 'hydration-log'];
+const dataTypeSchema = z
+    .enum(NUTRITION_DATA_TYPES)
+    .describe("Data type to roll up: 'nutrition-log' (calories and macronutrients) or 'hydration-log' (water)");
 /**
- * Registers Fitbit nutrition tools with the MCP server.
+ * Registers nutrition tools with the MCP server.
  * @param server The McpServer instance.
  * @param getAccessTokenFn Function to retrieve the current access token.
  */
 export function registerNutritionTools(server, getAccessTokenFn) {
-    // --- Food Log Tool (comprehensive nutrition data) ---
-    const foodLogToolName = 'get_food_log';
-    const foodLogDescription = 'Get comprehensive nutrition data (calories, protein, carbs, fat, fiber, sodium) from Fitbit food log for a specific date. Returns daily summary totals and individual food entries with nutritional values.';
-    const foodLogParametersSchemaShape = {
-        date: z
-            .string()
-            .regex(/^\d{4}-\d{2}-\d{2}$|^today$/, "Date must be in YYYY-MM-DD format or 'today'.")
-            .optional()
-            .describe("The date for which to retrieve food log data (YYYY-MM-DD or 'today'). Defaults to 'today'."),
-    };
-    server.tool(foodLogToolName, foodLogDescription, foodLogParametersSchemaShape, async ({ date = 'today', }) => {
-        // Construct the endpoint
-        const endpoint = `foods/log/date/${date}.json`;
-        const foodLogData = await makeFitbitRequest(endpoint, getAccessTokenFn, FITBIT_API_BASE);
-        // Handle API call failure
-        if (!foodLogData) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Failed to retrieve food log data from Fitbit API for date '${date}'. Check token and permissions.`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-        // Return successful response with raw JSON
-        const rawJsonResponse = JSON.stringify(foodLogData, null, 2);
-        return {
-            content: [{ type: 'text', text: rawJsonResponse }],
-        };
+    // --- Food Log Tool ---
+    registerTool(server, {
+        name: 'get_food_log',
+        description: 'Get the raw JSON response for logged nutrition entries from the Google Health API (data type "nutrition-log"), filtered by civil start time. Requires a start civil time; the end is optional and exclusive. Supports pagination via pageToken.',
+        parametersSchema: {
+            startTime: CommonSchemas.civilStartTime,
+            endTime: CommonSchemas.civilEndTime,
+            pageSize: CommonSchemas.pageSize,
+            pageToken: CommonSchemas.pageToken,
+        },
+        handler: async ({ startTime, endTime, pageSize, pageToken, }) => listDataPoints('nutrition-log', getAccessTokenFn, {
+            filter: buildRangeFilter('nutrition_log.interval.civil_start_time', startTime, endTime),
+            pageSize,
+            pageToken,
+        }, `food log from '${startTime}'${endTime ? ` to '${endTime}'` : ''}`),
     });
-    // --- Nutrition by Date/Period Tool ---
-    const periodToolName = 'get_nutrition';
-    const periodDescription = "Get the raw JSON response for nutrition data from Fitbit for a specified resource and period ending today or on a specific date. Requires 'resource' parameter (caloriesIn, water) and 'period' parameter such as '1d', '7d', '30d', '1w', '1m', '3m', '6m', '1y' and optionally accepts 'date' parameter.";
-    const periodParametersSchemaShape = {
-        resource: z
-            .enum([
-            'caloriesIn',
-            'water',
-            'protein',
-            'carbs',
-            'fat',
-            'fiber',
-            'sodium',
-        ])
-            .describe('The nutrition resource to retrieve data for.'),
-        period: z
-            .enum(['1d', '7d', '30d', '1w', '1m', '3m', '6m', '1y'])
-            .describe('The time period for which to retrieve nutrition data.'),
-        date: z
-            .string()
-            .regex(/^\d{4}-\d{2}-\d{2}$|^today$/, "Date must be in YYYY-MM-DD format or 'today'.")
-            .optional()
-            .describe("The date for which to retrieve nutrition data (YYYY-MM-DD or 'today'). Defaults to 'today'."),
-    };
-    server.tool(periodToolName, periodDescription, periodParametersSchemaShape, async ({ resource, period, date = 'today', }) => {
-        // Construct the endpoint dynamically
-        const endpoint = `foods/log/${resource}/date/${date}/${period}.json`;
-        const nutritionData = await makeFitbitRequest(endpoint, getAccessTokenFn, FITBIT_API_BASE);
-        // Handle API call failure
-        if (!nutritionData) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Failed to retrieve nutrition data from Fitbit API for resource '${resource}', date '${date}' and period '${period}'. Check token and permissions.`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-        // Handle no data found for the period
-        const resourceKey = `foods-log-${resource}`;
-        const nutritionEntries = nutritionData[resourceKey] || [];
-        if (nutritionEntries.length === 0) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `No nutrition data found for resource '${resource}', date '${date}' and period '${period}'.`,
-                    },
-                ],
-            };
-        }
-        // Return successful response with raw JSON
-        const rawJsonResponse = JSON.stringify(nutritionData, null, 2);
-        return {
-            content: [{ type: 'text', text: rawJsonResponse }],
-        };
+    // --- Nutrition for a single date ---
+    registerTool(server, {
+        name: 'get_nutrition',
+        description: 'Get the raw JSON response for the daily nutrition roll-up from the Google Health API (dailyRollUp) for a single date.',
+        parametersSchema: {
+            dataType: dataTypeSchema,
+            date: CommonSchemas.date,
+        },
+        handler: async ({ dataType, date, }) => dailyRollUp(dataType, getAccessTokenFn, { startDate: date, endDate: nextDate(date) }, `${dataType} for ${date}`),
     });
-    // --- Nutrition by Date Range Tool ---
-    const rangeToolName = 'get_nutrition_by_date_range';
-    const rangeDescription = "Get the raw JSON response for nutrition data from Fitbit for a specific resource and date range. Requires 'resource' parameter (caloriesIn, water), 'startDate' and 'endDate' parameters in 'YYYY-MM-DD' format. Note: The API enforces a maximum range of 1,095 days.";
-    const rangeParametersSchemaShape = {
-        resource: z
-            .enum([
-            'caloriesIn',
-            'water',
-            'protein',
-            'carbs',
-            'fat',
-            'fiber',
-            'sodium',
-        ])
-            .describe('The nutrition resource to retrieve data for.'),
-        startDate: z
-            .string()
-            .regex(/^\d{4}-\d{2}-\d{2}$/, 'Start date must be in YYYY-MM-DD format.')
-            .describe('The start date for which to retrieve nutrition data (YYYY-MM-DD).'),
-        endDate: z
-            .string()
-            .regex(/^\d{4}-\d{2}-\d{2}$/, 'End date must be in YYYY-MM-DD format.')
-            .describe('The end date for which to retrieve nutrition data (YYYY-MM-DD).'),
-    };
-    server.tool(rangeToolName, rangeDescription, rangeParametersSchemaShape, async ({ resource, startDate, endDate, }) => {
-        // Construct the endpoint dynamically
-        const endpoint = `foods/log/${resource}/date/${startDate}/${endDate}.json`;
-        // Make the request
-        const nutritionData = await makeFitbitRequest(endpoint, getAccessTokenFn, FITBIT_API_BASE);
-        // Handle API call failure
-        if (!nutritionData) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Failed to retrieve nutrition data from Fitbit API for resource '${resource}' and the date range '${startDate}' to '${endDate}'. Check token, permissions, date format, and ensure the range is 1,095 days or less.`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-        // Handle no data found
-        const resourceKey = `foods-log-${resource}`;
-        const nutritionEntries = nutritionData[resourceKey] || [];
-        if (nutritionEntries.length === 0) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `No nutrition data found for resource '${resource}' and the date range '${startDate}' to '${endDate}'.`,
-                    },
-                ],
-            };
-        }
-        // Return successful response
-        const rawJsonResponse = JSON.stringify(nutritionData, null, 2);
-        return {
-            content: [{ type: 'text', text: rawJsonResponse }],
-        };
+    // --- Nutrition by date range ---
+    registerTool(server, {
+        name: 'get_nutrition_by_date_range',
+        description: 'Get the raw JSON response for daily nutrition roll-ups from the Google Health API (dailyRollUp) over a civil date range. startDate is inclusive, endDate is exclusive. Note: The API allows at most 90 days per request.',
+        parametersSchema: {
+            dataType: dataTypeSchema,
+            startDate: CommonSchemas.startDate,
+            endDate: CommonSchemas.endDate,
+        },
+        handler: async ({ dataType, startDate, endDate, }) => dailyRollUp(dataType, getAccessTokenFn, { startDate, endDate }, `${dataType} from ${startDate} to ${endDate}`),
     });
 }

package/build/profile.js

@@ -1,19 +1,16 @@
-import { registerTool, handleFitbitApiCall } from './utils.js';
+import { registerTool, handleGoogleHealthCall } from './utils.js';
 /**
- * Registers a single, parameterized Fitbit profile tool with the MCP server.
+ * Registers the profile tool with the MCP server.
  * @param server The McpServer instance.
  * @param getAccessTokenFn Function to retrieve the current access token.
  */
 export function registerProfileTool(server, getAccessTokenFn) {
     registerTool(server, {
         name: 'get_profile',
-        description: "Get the raw JSON response for the user's Fitbit profile.",
+        description: "Get the raw JSON response for the user's Google Health profile (age, membership start date, stride lengths).",
         parametersSchema: {},
-        handler: async () => {
-            const endpoint = 'profile.json';
-            return handleFitbitApiCall(endpoint, {}, getAccessTokenFn, {
-                errorContext: 'profile data'
-            });
-        }
+        handler: async () => handleGoogleHealthCall('users/me/profile', getAccessTokenFn, {
+            errorContext: 'profile data',
+        }),
     });
 }

package/build/sleep.js

@@ -1,27 +1,23 @@
-import { registerTool, CommonSchemas, handleFitbitApiCall } from './utils.js';
-import { FITBIT_API_VERSIONS, VALIDATION_MESSAGES } from './config.js';
-// --- Tool Registration ---
+import { registerTool, CommonSchemas, listDataPoints, buildRangeFilter, } from './utils.js';
 /**
- * Registers a single, parameterized Fitbit sleep tool with the MCP server for a date range.
+ * Registers the sleep tool with the MCP server (Google Health `sleep` data type).
  * @param server The McpServer instance.
  * @param getAccessTokenFn Function to retrieve the current access token.
  */
 export function registerSleepTool(server, getAccessTokenFn) {
     registerTool(server, {
         name: 'get_sleep_by_date_range',
-        description: `Get the raw JSON response for sleep logs from Fitbit for a specific date range. Requires 'startDate' and 'endDate' parameters in 'YYYY-MM-DD' format. ${VALIDATION_MESSAGES.MAX_RANGE_100_DAYS}.`,
+        description: 'Get the raw JSON response for sleep sessions from the Google Health API (data type "sleep"), filtered by the civil end time of the sleep. Requires a start civil time; the end is optional and exclusive. Note: the API returns at most 25 sleep sessions per page; use pageToken to continue.',
         parametersSchema: {
-            startDate: CommonSchemas.startDate,
-            endDate: CommonSchemas.endDate,
+            startTime: CommonSchemas.civilStartTime,
+            endTime: CommonSchemas.civilEndTime,
+            pageSize: CommonSchemas.pageSize,
+            pageToken: CommonSchemas.pageToken,
         },
-        handler: async ({ startDate, endDate }) => {
-            const endpoint = `/sleep/date/${startDate}/${endDate}.json`;
-            return handleFitbitApiCall(endpoint, { startDate, endDate }, getAccessTokenFn, {
-                apiBase: FITBIT_API_VERSIONS.V1_2,
-                successDataExtractor: (data) => data.sleep || [],
-                noDataMessage: `the date range '${startDate}' to '${endDate}'`,
-                errorContext: `date range '${startDate}' to '${endDate}'`
-            });
-        }
+        handler: async ({ startTime, endTime, pageSize, pageToken, }) => listDataPoints('sleep', getAccessTokenFn, {
+            filter: buildRangeFilter('sleep.interval.civil_end_time', startTime, endTime),
+            pageSize,
+            pageToken,
+        }, `sleep from '${startTime}'${endTime ? ` to '${endTime}'` : ''}`),
     });
 }