@ryancardin/noaa-tides-currents-mcp-server 1.0.0

package/dist/sun-service.js

@@ -0,0 +1,218 @@
+import SunCalc from 'suncalc';
+import { z } from 'zod';
+/**
+ * Sun event types
+ */
+export var SunEventType;
+(function (SunEventType) {
+    SunEventType["SUNRISE"] = "sunrise";
+    SunEventType["SUNSET"] = "sunset";
+    SunEventType["DAWN"] = "dawn";
+    SunEventType["DUSK"] = "dusk";
+    SunEventType["SOLAR_NOON"] = "solarNoon";
+    SunEventType["NIGHT_START"] = "night";
+    SunEventType["NIGHT_END"] = "nightEnd";
+    SunEventType["GOLDEN_HOUR_START"] = "goldenHourStart";
+    SunEventType["GOLDEN_HOUR_END"] = "goldenHourEnd";
+    SunEventType["NAUTICAL_DAWN"] = "nauticalDawn";
+    SunEventType["NAUTICAL_DUSK"] = "nauticalDusk";
+    SunEventType["ASTRONOMICAL_DAWN"] = "astronomicalDawn";
+    SunEventType["ASTRONOMICAL_DUSK"] = "astronomicalDusk";
+})(SunEventType || (SunEventType = {}));
+/**
+ * Parameters for getting sun times
+ */
+export const SunTimesParamsSchema = z.object({
+    date: z.string().optional().describe('Date to get sun times for (YYYY-MM-DD format). Defaults to current date.'),
+    latitude: z.number().min(-90).max(90).describe('Latitude for location-specific calculations'),
+    longitude: z.number().min(-180).max(180).describe('Longitude for location-specific calculations'),
+    format: z.enum(['json', 'text']).optional().describe('Output format (json or text)'),
+    timezone: z.string().optional().describe('Timezone for the results. Defaults to UTC.')
+});
+/**
+ * Parameters for getting sun times for a date range
+ */
+export const SunTimesRangeParamsSchema = z.object({
+    start_date: z.string().describe('Start date (YYYY-MM-DD format)'),
+    end_date: z.string().describe('End date (YYYY-MM-DD format)'),
+    latitude: z.number().min(-90).max(90).describe('Latitude for location-specific calculations'),
+    longitude: z.number().min(-180).max(180).describe('Longitude for location-specific calculations'),
+    format: z.enum(['json', 'text']).optional().describe('Output format (json or text)'),
+    timezone: z.string().optional().describe('Timezone for the results. Defaults to UTC.')
+});
+/**
+ * Parameters for getting sun position
+ */
+export const SunPositionParamsSchema = z.object({
+    date: z.string().optional().describe('Date to get sun position for (YYYY-MM-DD format). Defaults to current date.'),
+    time: z.string().optional().describe('Time to get sun position for (HH:MM:SS format). Defaults to current time.'),
+    latitude: z.number().min(-90).max(90).describe('Latitude for location-specific calculations'),
+    longitude: z.number().min(-180).max(180).describe('Longitude for location-specific calculations'),
+    format: z.enum(['json', 'text']).optional().describe('Output format (json or text)')
+});
+/**
+ * Parameters for finding the next sun event
+ */
+export const NextSunEventParamsSchema = z.object({
+    event: z.nativeEnum(SunEventType).describe('Sun event to find'),
+    date: z.string().optional().describe('Starting date (YYYY-MM-DD format). Defaults to current date.'),
+    latitude: z.number().min(-90).max(90).describe('Latitude for location-specific calculations'),
+    longitude: z.number().min(-180).max(180).describe('Longitude for location-specific calculations'),
+    count: z.number().positive().optional().describe('Number of occurrences to return. Defaults to 1.'),
+    format: z.enum(['json', 'text']).optional().describe('Output format (json or text)'),
+    timezone: z.string().optional().describe('Timezone for the results. Defaults to UTC.')
+});
+/**
+ * Service for sun calculations
+ */
+export class SunService {
+    /**
+     * Get sun times for a specific date and location
+     * @param params Parameters for the request
+     * @returns Sun times information
+     */
+    getSunTimes(params) {
+        const date = params.date ? new Date(params.date) : new Date();
+        const { latitude, longitude } = params;
+        // Get sun times data
+        const sunTimes = SunCalc.getTimes(date, latitude, longitude);
+        // Format times or return null if not available
+        const formatTime = (time) => {
+            if (!time || isNaN(time.getTime()))
+                return null;
+            if (params.timezone) {
+                try {
+                    return time.toLocaleTimeString('en-US', { timeZone: params.timezone });
+                }
+                catch (error) {
+                    // If timezone is invalid, fall back to ISO string
+                    console.warn(`Invalid timezone: ${params.timezone}. Using UTC.`);
+                }
+            }
+            return time.toISOString();
+        };
+        // Calculate day length in minutes
+        const sunrise = sunTimes.sunrise;
+        const sunset = sunTimes.sunset;
+        let dayLength = 0;
+        if (sunrise && sunset && !isNaN(sunrise.getTime()) && !isNaN(sunset.getTime())) {
+            dayLength = (sunset.getTime() - sunrise.getTime()) / (60 * 1000);
+        }
+        return {
+            date: date.toISOString().split('T')[0],
+            sunrise: formatTime(sunTimes.sunrise),
+            sunset: formatTime(sunTimes.sunset),
+            solarNoon: formatTime(sunTimes.solarNoon),
+            dawn: formatTime(sunTimes.dawn),
+            dusk: formatTime(sunTimes.dusk),
+            nightStart: formatTime(sunTimes.night),
+            nightEnd: formatTime(sunTimes.nightEnd),
+            goldenHourStart: formatTime(sunTimes.goldenHour),
+            goldenHourEnd: formatTime(sunTimes.goldenHourEnd),
+            nauticalDawn: formatTime(sunTimes.nauticalDawn),
+            nauticalDusk: formatTime(sunTimes.nauticalDusk),
+            astronomicalDawn: formatTime(sunTimes.astronomicalDawn),
+            astronomicalDusk: formatTime(sunTimes.astronomicalDusk),
+            dayLength
+        };
+    }
+    /**
+     * Get sun times for a date range
+     * @param params Parameters for the request
+     * @returns Array of sun times information
+     */
+    getSunTimesRange(params) {
+        const startDate = new Date(params.start_date);
+        const endDate = new Date(params.end_date);
+        if (isNaN(startDate.getTime()) || isNaN(endDate.getTime())) {
+            throw new Error('Invalid date format. Please use YYYY-MM-DD format.');
+        }
+        if (startDate > endDate) {
+            throw new Error('Start date must be before end date.');
+        }
+        const result = [];
+        const currentDate = new Date(startDate);
+        while (currentDate <= endDate) {
+            result.push(this.getSunTimes({
+                date: currentDate.toISOString().split('T')[0],
+                latitude: params.latitude,
+                longitude: params.longitude,
+                timezone: params.timezone
+            }));
+            // Move to next day
+            currentDate.setDate(currentDate.getDate() + 1);
+        }
+        return result;
+    }
+    /**
+     * Get sun position for a specific date, time, and location
+     * @param params Parameters for the request
+     * @returns Sun position information
+     */
+    getSunPosition(params) {
+        const date = params.date ? new Date(params.date) : new Date();
+        // If time is provided, set it on the date object
+        if (params.time) {
+            const [hours, minutes, seconds] = params.time.split(':').map(Number);
+            date.setHours(hours || 0, minutes || 0, seconds || 0);
+        }
+        const { latitude, longitude } = params;
+        // Get sun position data
+        const position = SunCalc.getPosition(date, latitude, longitude);
+        // Calculate additional astronomical data
+        const declination = Math.asin(Math.sin(23.44 * Math.PI / 180) * Math.sin(position.azimuth));
+        const rightAscension = Math.atan2(Math.cos(23.44 * Math.PI / 180) * Math.sin(position.azimuth), Math.cos(position.azimuth));
+        return {
+            date: date.toISOString().split('T')[0],
+            time: date.toISOString().split('T')[1].split('.')[0],
+            azimuth: position.azimuth * (180 / Math.PI), // Convert to degrees
+            altitude: position.altitude * (180 / Math.PI), // Convert to degrees
+            declination: declination * (180 / Math.PI), // Convert to degrees
+            rightAscension: rightAscension * (180 / Math.PI) // Convert to degrees
+        };
+    }
+    /**
+     * Get the next occurrence(s) of a specific sun event
+     * @param params Parameters for the request
+     * @returns Array of dates for the next occurrences of the specified event
+     */
+    getNextSunEvent(params) {
+        const startDate = params.date ? new Date(params.date) : new Date();
+        const count = params.count || 1;
+        const { latitude, longitude, event } = params;
+        const results = [];
+        let currentDate = new Date(startDate);
+        // Find the next occurrences
+        while (results.length < count) {
+            // Get sun times for the current date
+            const sunTimes = SunCalc.getTimes(currentDate, latitude, longitude);
+            const eventTime = sunTimes[event];
+            // If the event time is valid and in the future
+            if (eventTime && !isNaN(eventTime.getTime()) && eventTime > startDate) {
+                let timeString = eventTime.toISOString();
+                // Format time based on timezone if provided
+                if (params.timezone) {
+                    try {
+                        timeString = eventTime.toLocaleTimeString('en-US', { timeZone: params.timezone });
+                    }
+                    catch (error) {
+                        // If timezone is invalid, fall back to ISO string
+                        console.warn(`Invalid timezone: ${params.timezone}. Using UTC.`);
+                    }
+                }
+                results.push({
+                    date: eventTime.toISOString().split('T')[0],
+                    time: timeString.split('T')[1]?.split('.')[0] || timeString,
+                    event
+                });
+            }
+            // Move to next day
+            currentDate.setDate(currentDate.getDate() + 1);
+            // Safety check to prevent infinite loops
+            if (results.length === 0 && currentDate.getTime() - startDate.getTime() > 366 * 24 * 60 * 60 * 1000) {
+                throw new Error('Could not find the specified sun event within a year.');
+            }
+        }
+        return results;
+    }
+}

package/dist/tools/derived-product-tools.d.ts

@@ -0,0 +1,6 @@
+import { FastMCP } from 'fastmcp';
+import { DpapiService } from '../services/dpapi-service.js';
+/**
+ * Register derived product tools with the MCP server
+ */
+export declare function registerDerivedProductTools(server: FastMCP, dpapiService: DpapiService): void;

package/dist/tools/derived-product-tools.js

@@ -0,0 +1,168 @@
+import { SeaLevelTrendsSchema, ExtremeWaterLevelsSchema, HighTideFloodingDailySchema, HighTideFloodingMonthlySchema, HighTideFloodingSeasonalSchema, HighTideFloodingAnnualSchema, HighTideFloodingProjectionsSchema, HighTideFloodingLikelihoodsSchema, TopTenWaterLevelsSchema } from '../schemas/dpapi.js';
+/**
+ * Register derived product tools with the MCP server
+ */
+export function registerDerivedProductTools(server, dpapiService) {
+    // Sea Level Trends tool
+    server.addTool({
+        name: 'get_sea_level_trends',
+        description: 'Get sea level trends and error margins for a station',
+        parameters: SeaLevelTrendsSchema,
+        execute: async (params) => {
+            try {
+                const result = await dpapiService.getSeaLevelTrends(params);
+                return JSON.stringify(result);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to get sea level trends: ${error.message}`);
+                }
+                throw new Error('Failed to get sea level trends');
+            }
+        }
+    });
+    // Extreme Water Levels tool
+    server.addTool({
+        name: 'get_extreme_water_levels',
+        description: 'Get extreme water levels and exceedance probabilities for a station',
+        parameters: ExtremeWaterLevelsSchema,
+        execute: async (params) => {
+            try {
+                const result = await dpapiService.getExtremeWaterLevels(params);
+                return JSON.stringify(result);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to get extreme water levels: ${error.message}`);
+                }
+                throw new Error('Failed to get extreme water levels');
+            }
+        }
+    });
+    // High Tide Flooding Daily tool
+    server.addTool({
+        name: 'get_high_tide_flooding_daily',
+        description: 'Get high tide flooding daily count data for a station',
+        parameters: HighTideFloodingDailySchema,
+        execute: async (params) => {
+            try {
+                const result = await dpapiService.getHighTideFloodingDaily(params);
+                return JSON.stringify(result);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to get high tide flooding daily data: ${error.message}`);
+                }
+                throw new Error('Failed to get high tide flooding daily data');
+            }
+        }
+    });
+    // High Tide Flooding Monthly tool
+    server.addTool({
+        name: 'get_high_tide_flooding_monthly',
+        description: 'Get high tide flooding monthly count data for a station',
+        parameters: HighTideFloodingMonthlySchema,
+        execute: async (params) => {
+            try {
+                const result = await dpapiService.getHighTideFloodingMonthly(params);
+                return JSON.stringify(result);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to get high tide flooding monthly data: ${error.message}`);
+                }
+                throw new Error('Failed to get high tide flooding monthly data');
+            }
+        }
+    });
+    // High Tide Flooding Seasonal tool
+    server.addTool({
+        name: 'get_high_tide_flooding_seasonal',
+        description: 'Get high tide flooding seasonal count data for a station',
+        parameters: HighTideFloodingSeasonalSchema,
+        execute: async (params) => {
+            try {
+                const result = await dpapiService.getHighTideFloodingSeasonal(params);
+                return JSON.stringify(result);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to get high tide flooding seasonal data: ${error.message}`);
+                }
+                throw new Error('Failed to get high tide flooding seasonal data');
+            }
+        }
+    });
+    // High Tide Flooding Annual tool
+    server.addTool({
+        name: 'get_high_tide_flooding_annual',
+        description: 'Get high tide flooding annual count data for a station',
+        parameters: HighTideFloodingAnnualSchema,
+        execute: async (params) => {
+            try {
+                const result = await dpapiService.getHighTideFloodingAnnual(params);
+                return JSON.stringify(result);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to get high tide flooding annual data: ${error.message}`);
+                }
+                throw new Error('Failed to get high tide flooding annual data');
+            }
+        }
+    });
+    // High Tide Flooding Projections tool
+    server.addTool({
+        name: 'get_high_tide_flooding_projections',
+        description: 'Get high tide flooding decadal projections for sea level rise scenarios',
+        parameters: HighTideFloodingProjectionsSchema,
+        execute: async (params) => {
+            try {
+                const result = await dpapiService.getHighTideFloodingProjections(params);
+                return JSON.stringify(result);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to get high tide flooding projections: ${error.message}`);
+                }
+                throw new Error('Failed to get high tide flooding projections');
+            }
+        }
+    });
+    // High Tide Flooding Likelihoods tool
+    server.addTool({
+        name: 'get_high_tide_flooding_likelihoods',
+        description: 'Get high tide flooding daily likelihoods for a station',
+        parameters: HighTideFloodingLikelihoodsSchema,
+        execute: async (params) => {
+            try {
+                const result = await dpapiService.getHighTideFloodingLikelihoods(params);
+                return JSON.stringify(result);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to get high tide flooding likelihoods: ${error.message}`);
+                }
+                throw new Error('Failed to get high tide flooding likelihoods');
+            }
+        }
+    });
+    // Top Ten Water Levels tool
+    server.addTool({
+        name: 'get_top_ten_water_levels',
+        description: 'Get top ten highest or lowest water levels for a station',
+        parameters: TopTenWaterLevelsSchema,
+        execute: async (params) => {
+            try {
+                const result = await dpapiService.getTopTenWaterLevels(params);
+                return JSON.stringify(result);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to get top ten water levels: ${error.message}`);
+                }
+                throw new Error('Failed to get top ten water levels');
+            }
+        }
+    });
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,16 @@
+import { FastMCP } from 'fastmcp';
+import { NoaaService } from '../services/noaa-service.js';
+import { MoonPhaseService } from '../services/moon-phase-service.js';
+import { SunService } from '../services/sun-service.js';
+import { NoaaParametersService } from '../services/noaa-parameters-service.js';
+import { DpapiService } from '../services/dpapi-service.js';
+/**
+ * Register all tools with the MCP server
+ */
+export declare function registerAllTools(server: FastMCP): {
+    noaaService: NoaaService;
+    moonPhaseService: MoonPhaseService;
+    sunService: SunService;
+    parametersService: NoaaParametersService;
+    dpapiService: DpapiService;
+};

package/dist/tools/index.js

@@ -0,0 +1,36 @@
+import { NoaaService } from '../services/noaa-service.js';
+import { MoonPhaseService } from '../services/moon-phase-service.js';
+import { SunService } from '../services/sun-service.js';
+import { NoaaParametersService } from '../services/noaa-parameters-service.js';
+import { DpapiService } from '../services/dpapi-service.js';
+import { registerWaterTools } from './water-tools.js';
+import { registerStationTools } from './station-tools.js';
+import { registerMoonTools } from './moon-tools.js';
+import { registerSunTools } from './sun-tools.js';
+import { registerParameterTools } from './parameter-tools.js';
+import { registerDerivedProductTools } from './derived-product-tools.js';
+/**
+ * Register all tools with the MCP server
+ */
+export function registerAllTools(server) {
+    // Create service instances
+    const noaaService = new NoaaService();
+    const moonPhaseService = new MoonPhaseService();
+    const sunService = new SunService();
+    const parametersService = new NoaaParametersService();
+    const dpapiService = new DpapiService();
+    // Register tools by category
+    registerWaterTools(server, noaaService);
+    registerStationTools(server, noaaService);
+    registerMoonTools(server, moonPhaseService);
+    registerSunTools(server, sunService);
+    registerParameterTools(server, parametersService);
+    registerDerivedProductTools(server, dpapiService);
+    return {
+        noaaService,
+        moonPhaseService,
+        sunService,
+        parametersService,
+        dpapiService
+    };
+}

package/dist/tools/moon-tools.d.ts

@@ -0,0 +1,6 @@
+import { FastMCP } from 'fastmcp';
+import { MoonPhaseService } from '../services/moon-phase-service.js';
+/**
+ * Register moon-related tools with the MCP server
+ */
+export declare function registerMoonTools(server: FastMCP, moonPhaseService: MoonPhaseService): void;

package/dist/tools/moon-tools.js

@@ -0,0 +1,69 @@
+import { MoonPhaseParamsSchema, MoonPhasesRangeParamsSchema, NextMoonPhaseParamsSchema } from '../interfaces/moon.js';
+/**
+ * Register moon-related tools with the MCP server
+ */
+export function registerMoonTools(server, moonPhaseService) {
+    // Add moon phase tool
+    server.addTool({
+        name: 'get_moon_phase',
+        description: 'Get moon phase information for a specific date',
+        parameters: MoonPhaseParamsSchema,
+        execute: async (params) => {
+            try {
+                const result = moonPhaseService.getMoonPhase(params);
+                if (params.format === 'text') {
+                    return `Moon phase for ${result.date}: ${result.phaseName} (${(result.illumination * 100).toFixed(1)}% illuminated)`;
+                }
+                return JSON.stringify(result);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to get moon phase: ${error.message}`);
+                }
+                throw new Error('Failed to get moon phase');
+            }
+        }
+    });
+    // Add moon phases range tool
+    server.addTool({
+        name: 'get_moon_phases_range',
+        description: 'Get moon phase information for a date range',
+        parameters: MoonPhasesRangeParamsSchema,
+        execute: async (params) => {
+            try {
+                const results = moonPhaseService.getMoonPhasesRange(params);
+                if (params.format === 'text') {
+                    return results.map(result => `${result.date}: ${result.phaseName} (${(result.illumination * 100).toFixed(1)}% illuminated)`).join('\n');
+                }
+                return JSON.stringify(results);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to get moon phases: ${error.message}`);
+                }
+                throw new Error('Failed to get moon phases');
+            }
+        }
+    });
+    // Add next moon phase tool
+    server.addTool({
+        name: 'get_next_moon_phase',
+        description: 'Get the next occurrence(s) of a specific moon phase',
+        parameters: NextMoonPhaseParamsSchema,
+        execute: async (params) => {
+            try {
+                const results = moonPhaseService.getNextMoonPhase(params);
+                if (params.format === 'text') {
+                    return results.map(result => `Next ${result.phase}: ${result.date}`).join('\n');
+                }
+                return JSON.stringify(results);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to get next moon phase: ${error.message}`);
+                }
+                throw new Error('Failed to get next moon phase');
+            }
+        }
+    });
+}

package/dist/tools/parameter-tools.d.ts

@@ -0,0 +1,6 @@
+import { FastMCP } from 'fastmcp';
+import { NoaaParametersService } from '../services/noaa-parameters-service.js';
+/**
+ * Register parameter tools with the MCP server
+ */
+export declare function registerParameterTools(server: FastMCP, parametersService: NoaaParametersService): void;

package/dist/tools/parameter-tools.js

@@ -0,0 +1,77 @@
+import { ParameterSchema } from '../interfaces/parameters.js';
+/**
+ * Register parameter tools with the MCP server
+ */
+export function registerParameterTools(server, parametersService) {
+    /**
+     * Add parameter definitions tool
+     */
+    server.addTool({
+        name: 'get_parameter_definitions',
+        description: 'Get information about valid parameter values for NOAA API requests',
+        parameters: ParameterSchema,
+        execute: async (params) => {
+            try {
+                const { parameter } = params;
+                // If no parameter specified, return all parameter types and their descriptions
+                if (!parameter) {
+                    return JSON.stringify({
+                        time_zones: parametersService.getTimeZones(),
+                        datums: parametersService.getDatums(),
+                        units: parametersService.getUnits(),
+                        tide_intervals: parametersService.getTidePredictionIntervals(),
+                        current_intervals: parametersService.getCurrentPredictionIntervals(),
+                        velocity_types: parametersService.getVelocityTypes(),
+                        products: parametersService.getMeteorologicalProducts(),
+                        station_types: parametersService.getStationTypes(),
+                        date_formats: parametersService.getDateFormats(),
+                        output_formats: parametersService.getOutputFormats()
+                    });
+                }
+                // Return specific parameter information based on the parameter type
+                let result;
+                switch (parameter) {
+                    case 'time_zones':
+                        result = parametersService.getTimeZones();
+                        break;
+                    case 'datums':
+                        result = parametersService.getDatums();
+                        break;
+                    case 'units':
+                        result = parametersService.getUnits();
+                        break;
+                    case 'tide_intervals':
+                        result = parametersService.getTidePredictionIntervals();
+                        break;
+                    case 'current_intervals':
+                        result = parametersService.getCurrentPredictionIntervals();
+                        break;
+                    case 'velocity_types':
+                        result = parametersService.getVelocityTypes();
+                        break;
+                    case 'products':
+                        result = parametersService.getMeteorologicalProducts();
+                        break;
+                    case 'station_types':
+                        result = parametersService.getStationTypes();
+                        break;
+                    case 'date_formats':
+                        result = parametersService.getDateFormats();
+                        break;
+                    case 'output_formats':
+                        result = parametersService.getOutputFormats();
+                        break;
+                    default:
+                        throw new Error(`Unknown parameter type: ${parameter}`);
+                }
+                return JSON.stringify(result);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to get parameter definitions: ${error.message}`);
+                }
+                throw new Error('Failed to get parameter definitions');
+            }
+        }
+    });
+}

package/dist/tools/station-tools.d.ts

@@ -0,0 +1,6 @@
+import { FastMCP } from 'fastmcp';
+import { NoaaService } from '../services/noaa-service.js';
+/**
+ * Register station-related tools with the MCP server
+ */
+export declare function registerStationTools(server: FastMCP, noaaService: NoaaService): void;

package/dist/tools/station-tools.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { StationSchema, UnitsSchema } from '../schemas/common.js';
+/**
+ * Register station-related tools with the MCP server
+ */
+export function registerStationTools(server, noaaService) {
+    // Add stations tool
+    server.addTool({
+        name: 'get_stations',
+        description: 'Get list of stations',
+        parameters: z.object({
+            type: z.string().optional().describe('Station type (waterlevels, currents, etc.)'),
+            format: z.enum(['json', 'xml']).optional().describe('Output format (json, xml)'),
+            units: UnitsSchema,
+        }),
+        execute: async (params) => {
+            try {
+                const result = await noaaService.getStations(params);
+                return JSON.stringify(result);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to get stations: ${error.message}`);
+                }
+                throw new Error('Failed to get stations');
+            }
+        }
+    });
+    // Add station details tool
+    server.addTool({
+        name: 'get_station_details',
+        description: 'Get detailed information about a station',
+        parameters: z.object({
+            station: StationSchema,
+            format: z.enum(['json', 'xml']).optional().describe('Output format (json, xml)'),
+            units: UnitsSchema,
+        }),
+        execute: async (params) => {
+            try {
+                const result = await noaaService.getStationDetails(params);
+                return JSON.stringify(result);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to get station details: ${error.message}`);
+                }
+                throw new Error('Failed to get station details');
+            }
+        }
+    });
+}