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

package/dist/mcp-server.js

@@ -0,0 +1,103 @@
+import { GetWaterLevelsSchema, GetTidePredictionsSchema, GetCurrentsSchema, GetCurrentPredictionsSchema, GetMeteorologicalDataSchema, GetStationsSchema, GetStationDetailsSchema } from './types.js';
+// Class for the MCP server
+export class McpServer {
+    tools;
+    noaaService;
+    constructor(noaaService) {
+        this.noaaService = noaaService;
+        this.tools = this.initializeTools();
+    }
+    // Initialize the tools
+    initializeTools() {
+        // Water Levels tool
+        const getWaterLevels = {
+            name: "get_water_levels",
+            description: "Get water level data for a station",
+            inputSchema: GetWaterLevelsSchema,
+            handler: async (params) => {
+                return this.noaaService.getWaterLevels(params);
+            }
+        };
+        // Tide Predictions tool
+        const getTidePredictions = {
+            name: "get_tide_predictions",
+            description: "Get tide prediction data",
+            inputSchema: GetTidePredictionsSchema,
+            handler: async (params) => {
+                return this.noaaService.getTidePredictions(params);
+            }
+        };
+        // Currents tool
+        const getCurrents = {
+            name: "get_currents",
+            description: "Get currents data for a station",
+            inputSchema: GetCurrentsSchema,
+            handler: async (params) => {
+                return this.noaaService.getCurrents(params);
+            }
+        };
+        // Current Predictions tool
+        const getCurrentPredictions = {
+            name: "get_current_predictions",
+            description: "Get current predictions",
+            inputSchema: GetCurrentPredictionsSchema,
+            handler: async (params) => {
+                return this.noaaService.getCurrentPredictions(params);
+            }
+        };
+        // Meteorological Data tool
+        const getMeteorologicalData = {
+            name: "get_meteorological_data",
+            description: "Get meteorological data",
+            inputSchema: GetMeteorologicalDataSchema,
+            handler: async (params) => {
+                return this.noaaService.getMeteorologicalData(params);
+            }
+        };
+        // Stations tool
+        const getStations = {
+            name: "get_stations",
+            description: "Get list of stations",
+            inputSchema: GetStationsSchema,
+            handler: async (params) => {
+                return this.noaaService.getStations(params);
+            }
+        };
+        // Station Details tool
+        const getStationDetails = {
+            name: "get_station_details",
+            description: "Get detailed information about a station",
+            inputSchema: GetStationDetailsSchema,
+            handler: async (params) => {
+                return this.noaaService.getStationDetails(params);
+            }
+        };
+        return [
+            getWaterLevels,
+            getTidePredictions,
+            getCurrents,
+            getCurrentPredictions,
+            getMeteorologicalData,
+            getStations,
+            getStationDetails
+        ];
+    }
+    // Method to get all tools
+    getTools() {
+        return this.tools.map(tool => ({
+            name: tool.name,
+            description: tool.description
+        }));
+    }
+    // Method to handle tool execution
+    async executeTool(toolName, params) {
+        const tool = this.tools.find(t => t.name === toolName);
+        if (!tool) {
+            throw new Error(`Tool '${toolName}' not found`);
+        }
+        // Validate the parameters against the schema
+        const validatedParams = tool.inputSchema.parse(params);
+        // Execute the tool handler
+        return tool.handler(validatedParams);
+    }
+}

package/dist/moon-phase-service.d.ts

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+/**
+ * Moon phase names and their approximate ranges
+ */
+export declare enum MoonPhaseName {
+    NEW_MOON = "New Moon",
+    WAXING_CRESCENT = "Waxing Crescent",
+    FIRST_QUARTER = "First Quarter",
+    WAXING_GIBBOUS = "Waxing Gibbous",
+    FULL_MOON = "Full Moon",
+    WANING_GIBBOUS = "Waning Gibbous",
+    LAST_QUARTER = "Last Quarter",
+    WANING_CRESCENT = "Waning Crescent"
+}
+/**
+ * Moon phase information
+ */
+export interface MoonPhaseInfo {
+    date: string;
+    phase: number;
+    phaseName: MoonPhaseName;
+    illumination: number;
+    age: number;
+    distance: number;
+    diameter: number;
+    isWaxing: boolean;
+}
+/**
+ * Parameters for getting moon phase
+ */
+export declare const MoonPhaseParamsSchema: z.ZodObject<{
+    date: z.ZodOptional<z.ZodString>;
+    latitude: z.ZodOptional<z.ZodNumber>;
+    longitude: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodOptional<z.ZodEnum<["json", "text"]>>;
+}, "strip", z.ZodTypeAny, {
+    date?: string | undefined;
+    format?: "text" | "json" | undefined;
+    latitude?: number | undefined;
+    longitude?: number | undefined;
+}, {
+    date?: string | undefined;
+    format?: "text" | "json" | undefined;
+    latitude?: number | undefined;
+    longitude?: number | undefined;
+}>;
+export type MoonPhaseParams = z.infer<typeof MoonPhaseParamsSchema>;
+/**
+ * Parameters for getting moon phases for a date range
+ */
+export declare const MoonPhasesRangeParamsSchema: z.ZodObject<{
+    start_date: z.ZodString;
+    end_date: z.ZodString;
+    latitude: z.ZodOptional<z.ZodNumber>;
+    longitude: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodOptional<z.ZodEnum<["json", "text"]>>;
+}, "strip", z.ZodTypeAny, {
+    start_date: string;
+    end_date: string;
+    format?: "text" | "json" | undefined;
+    latitude?: number | undefined;
+    longitude?: number | undefined;
+}, {
+    start_date: string;
+    end_date: string;
+    format?: "text" | "json" | undefined;
+    latitude?: number | undefined;
+    longitude?: number | undefined;
+}>;
+export type MoonPhasesRangeParams = z.infer<typeof MoonPhasesRangeParamsSchema>;
+/**
+ * Parameters for getting next moon phase
+ */
+export declare const NextMoonPhaseParamsSchema: z.ZodObject<{
+    phase: z.ZodEnum<[MoonPhaseName.NEW_MOON, MoonPhaseName.FIRST_QUARTER, MoonPhaseName.FULL_MOON, MoonPhaseName.LAST_QUARTER]>;
+    date: z.ZodOptional<z.ZodString>;
+    count: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodOptional<z.ZodEnum<["json", "text"]>>;
+}, "strip", z.ZodTypeAny, {
+    phase: MoonPhaseName.NEW_MOON | MoonPhaseName.FIRST_QUARTER | MoonPhaseName.FULL_MOON | MoonPhaseName.LAST_QUARTER;
+    date?: string | undefined;
+    format?: "text" | "json" | undefined;
+    count?: number | undefined;
+}, {
+    phase: MoonPhaseName.NEW_MOON | MoonPhaseName.FIRST_QUARTER | MoonPhaseName.FULL_MOON | MoonPhaseName.LAST_QUARTER;
+    date?: string | undefined;
+    format?: "text" | "json" | undefined;
+    count?: number | undefined;
+}>;
+export type NextMoonPhaseParams = z.infer<typeof NextMoonPhaseParamsSchema>;
+/**
+ * Service for moon phase calculations
+ */
+export declare class MoonPhaseService {
+    /**
+     * Get the moon phase for a specific date
+     * @param params Parameters for the request
+     * @returns Moon phase information
+     */
+    getMoonPhase(params: MoonPhaseParams): MoonPhaseInfo;
+    /**
+     * Get moon phases for a date range
+     * @param params Parameters for the request
+     * @returns Array of moon phase information
+     */
+    getMoonPhasesRange(params: MoonPhasesRangeParams): MoonPhaseInfo[];
+    /**
+     * Get the next occurrence(s) of a specific moon phase
+     * @param params Parameters for the request
+     * @returns Array of dates for the next occurrences of the specified phase
+     */
+    getNextMoonPhase(params: NextMoonPhaseParams): {
+        date: string;
+        phase: string;
+    }[];
+    /**
+     * Get the name of the moon phase based on the phase value
+     * @param phase Phase value (0-1)
+     * @returns Moon phase name
+     */
+    private getMoonPhaseName;
+}

package/dist/moon-phase-service.js

@@ -0,0 +1,187 @@
+import SunCalc from 'suncalc';
+import { z } from 'zod';
+/**
+ * Moon phase names and their approximate ranges
+ */
+export var MoonPhaseName;
+(function (MoonPhaseName) {
+    MoonPhaseName["NEW_MOON"] = "New Moon";
+    MoonPhaseName["WAXING_CRESCENT"] = "Waxing Crescent";
+    MoonPhaseName["FIRST_QUARTER"] = "First Quarter";
+    MoonPhaseName["WAXING_GIBBOUS"] = "Waxing Gibbous";
+    MoonPhaseName["FULL_MOON"] = "Full Moon";
+    MoonPhaseName["WANING_GIBBOUS"] = "Waning Gibbous";
+    MoonPhaseName["LAST_QUARTER"] = "Last Quarter";
+    MoonPhaseName["WANING_CRESCENT"] = "Waning Crescent";
+})(MoonPhaseName || (MoonPhaseName = {}));
+/**
+ * Parameters for getting moon phase
+ */
+export const MoonPhaseParamsSchema = z.object({
+    date: z.string().optional().describe('Date to get moon phase for (YYYY-MM-DD format). Defaults to current date.'),
+    latitude: z.number().min(-90).max(90).optional().describe('Latitude for location-specific calculations'),
+    longitude: z.number().min(-180).max(180).optional().describe('Longitude for location-specific calculations'),
+    format: z.enum(['json', 'text']).optional().describe('Output format (json or text)')
+});
+/**
+ * Parameters for getting moon phases for a date range
+ */
+export const MoonPhasesRangeParamsSchema = 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).optional().describe('Latitude for location-specific calculations'),
+    longitude: z.number().min(-180).max(180).optional().describe('Longitude for location-specific calculations'),
+    format: z.enum(['json', 'text']).optional().describe('Output format (json or text)')
+});
+/**
+ * Parameters for getting next moon phase
+ */
+export const NextMoonPhaseParamsSchema = z.object({
+    phase: z.enum([
+        MoonPhaseName.NEW_MOON,
+        MoonPhaseName.FIRST_QUARTER,
+        MoonPhaseName.FULL_MOON,
+        MoonPhaseName.LAST_QUARTER
+    ]).describe('Moon phase to find'),
+    date: z.string().optional().describe('Starting date (YYYY-MM-DD format). Defaults to current date.'),
+    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)')
+});
+/**
+ * Service for moon phase calculations
+ */
+export class MoonPhaseService {
+    /**
+     * Get the moon phase for a specific date
+     * @param params Parameters for the request
+     * @returns Moon phase information
+     */
+    getMoonPhase(params) {
+        const date = params.date ? new Date(params.date) : new Date();
+        // Get moon illumination data
+        const illuminationData = SunCalc.getMoonIllumination(date);
+        // Get moon position data (requires location)
+        const latitude = params.latitude ?? 0;
+        const longitude = params.longitude ?? 0;
+        const positionData = SunCalc.getMoonPosition(date, latitude, longitude);
+        // Calculate moon phase name
+        const phaseName = this.getMoonPhaseName(illuminationData.phase);
+        // Calculate if the moon is waxing (increasing illumination)
+        const isWaxing = illuminationData.phase < 0.5;
+        // Calculate approximate moon age (0-29.53 days)
+        const lunarMonth = 29.53; // days
+        const age = illuminationData.phase * lunarMonth;
+        // Calculate apparent diameter (in degrees)
+        const diameter = 0.5181 * (384400 / positionData.distance);
+        return {
+            date: date.toISOString().split('T')[0],
+            phase: illuminationData.phase,
+            phaseName,
+            illumination: illuminationData.fraction,
+            age,
+            distance: positionData.distance,
+            diameter,
+            isWaxing
+        };
+    }
+    /**
+     * Get moon phases for a date range
+     * @param params Parameters for the request
+     * @returns Array of moon phase information
+     */
+    getMoonPhasesRange(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.getMoonPhase({
+                date: currentDate.toISOString().split('T')[0],
+                latitude: params.latitude,
+                longitude: params.longitude
+            }));
+            // Move to next day
+            currentDate.setDate(currentDate.getDate() + 1);
+        }
+        return result;
+    }
+    /**
+     * Get the next occurrence(s) of a specific moon phase
+     * @param params Parameters for the request
+     * @returns Array of dates for the next occurrences of the specified phase
+     */
+    getNextMoonPhase(params) {
+        const startDate = params.date ? new Date(params.date) : new Date();
+        const count = params.count || 1;
+        const targetPhase = params.phase;
+        // Map phase names to their approximate values
+        const phaseValues = {
+            [MoonPhaseName.NEW_MOON]: 0,
+            [MoonPhaseName.FIRST_QUARTER]: 0.25,
+            [MoonPhaseName.FULL_MOON]: 0.5,
+            [MoonPhaseName.LAST_QUARTER]: 0.75
+        };
+        const targetPhaseValue = phaseValues[targetPhase];
+        const results = [];
+        let currentDate = new Date(startDate);
+        // Find the next occurrences
+        while (results.length < count) {
+            // Check every day (could be optimized with better algorithms)
+            const illuminationData = SunCalc.getMoonIllumination(currentDate);
+            const prevDate = new Date(currentDate);
+            prevDate.setDate(prevDate.getDate() - 1);
+            const prevIlluminationData = SunCalc.getMoonIllumination(prevDate);
+            // Check if we've passed the target phase between yesterday and today
+            const prevDiff = Math.abs(prevIlluminationData.phase - targetPhaseValue);
+            const currentDiff = Math.abs(illuminationData.phase - targetPhaseValue);
+            // If we're getting closer to the target phase and then further away, we've passed it
+            // Or if we're very close to the target phase (within 0.01)
+            if ((prevDiff > currentDiff && currentDiff < 0.01) || currentDiff < 0.005) {
+                results.push({
+                    date: currentDate.toISOString().split('T')[0],
+                    phase: targetPhase
+                });
+            }
+            // 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 moon phase within a year.');
+            }
+        }
+        return results;
+    }
+    /**
+     * Get the name of the moon phase based on the phase value
+     * @param phase Phase value (0-1)
+     * @returns Moon phase name
+     */
+    getMoonPhaseName(phase) {
+        // Normalize phase to 0-1 range
+        phase = phase % 1;
+        if (phase < 0)
+            phase += 1;
+        // Determine phase name based on value ranges
+        if (phase < 0.0625 || phase >= 0.9375)
+            return MoonPhaseName.NEW_MOON;
+        if (phase < 0.1875)
+            return MoonPhaseName.WAXING_CRESCENT;
+        if (phase < 0.3125)
+            return MoonPhaseName.FIRST_QUARTER;
+        if (phase < 0.4375)
+            return MoonPhaseName.WAXING_GIBBOUS;
+        if (phase < 0.5625)
+            return MoonPhaseName.FULL_MOON;
+        if (phase < 0.6875)
+            return MoonPhaseName.WANING_GIBBOUS;
+        if (phase < 0.8125)
+            return MoonPhaseName.LAST_QUARTER;
+        return MoonPhaseName.WANING_CRESCENT;
+    }
+}

package/dist/noaa-service.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Configuration options for the NOAA service
+ */
+export interface NoaaConfig {
+    applicationName?: string;
+}
+/**
+ * Service for interacting with NOAA Tides and Currents APIs
+ */
+export declare class NoaaService {
+    private config;
+    constructor(config?: NoaaConfig);
+    /**
+     * Build parameters for the API request
+     * @param params Parameters for the request
+     * @returns URL-encoded parameters string
+     */
+    private buildParams;
+    /**
+     * Make a request to the Data API
+     * @param params Parameters for the request
+     * @returns Response data
+     */
+    fetchDataApi(params: Record<string, any>): Promise<any>;
+    /**
+     * Make a request to the Metadata API
+     * @param endpoint Endpoint path
+     * @param params Parameters for the request
+     * @returns Response data
+     */
+    fetchMetadataApi(endpoint: string, params?: Record<string, any>): Promise<any>;
+    /**
+     * Get water level data
+     */
+    getWaterLevels(params: Record<string, any>): Promise<any>;
+    /**
+     * Get tide predictions
+     */
+    getTidePredictions(params: Record<string, any>): Promise<any>;
+    /**
+     * Get currents data
+     */
+    getCurrents(params: Record<string, any>): Promise<any>;
+    /**
+     * Get current predictions
+     */
+    getCurrentPredictions(params: Record<string, any>): Promise<any>;
+    /**
+     * Get meteorological data (air_temperature, wind, etc.)
+     */
+    getMeteorologicalData(params: Record<string, any>): Promise<any>;
+    /**
+     * Get list of stations
+     */
+    getStations(params: Record<string, any>): Promise<any>;
+    /**
+     * Get station details
+     */
+    getStationDetails(params: Record<string, any>): Promise<any>;
+}

package/dist/noaa-service.js

@@ -0,0 +1,159 @@
+import axios from 'axios';
+// Base URLs for the different NOAA APIs
+const DATA_API_BASE_URL = 'https://api.tidesandcurrents.noaa.gov/api/prod/datagetter';
+const METADATA_API_BASE_URL = 'https://api.tidesandcurrents.noaa.gov/mdapi/prod/webapi';
+/**
+ * Service for interacting with NOAA Tides and Currents APIs
+ */
+export class NoaaService {
+    config;
+    constructor(config = {}) {
+        this.config = config;
+    }
+    /**
+     * Build parameters for the API request
+     * @param params Parameters for the request
+     * @returns URL-encoded parameters string
+     */
+    buildParams(params) {
+        // Add application name if provided in config
+        if (this.config.applicationName) {
+            params.application = this.config.applicationName;
+        }
+        // Remove undefined and null values
+        const filteredParams = Object.entries(params)
+            .filter(([_, value]) => value !== undefined && value !== null)
+            .reduce((acc, [key, value]) => {
+            acc[key] = value;
+            return acc;
+        }, {});
+        // Convert to URL parameters
+        return new URLSearchParams(filteredParams).toString();
+    }
+    /**
+     * Make a request to the Data API
+     * @param params Parameters for the request
+     * @returns Response data
+     */
+    async fetchDataApi(params) {
+        try {
+            const queryParams = this.buildParams(params);
+            const url = `${DATA_API_BASE_URL}?${queryParams}`;
+            const response = await axios.get(url);
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response) {
+                throw new Error(`NOAA API Error: ${error.response.status} - ${JSON.stringify(error.response.data)}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Make a request to the Metadata API
+     * @param endpoint Endpoint path
+     * @param params Parameters for the request
+     * @returns Response data
+     */
+    async fetchMetadataApi(endpoint, params = {}) {
+        try {
+            const queryParams = this.buildParams(params);
+            const url = `${METADATA_API_BASE_URL}${endpoint}${queryParams ? '?' + queryParams : ''}`;
+            const response = await axios.get(url);
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response) {
+                throw new Error(`NOAA API Error: ${error.response.status} - ${JSON.stringify(error.response.data)}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get water level data
+     */
+    async getWaterLevels(params) {
+        return this.fetchDataApi({
+            ...params,
+            product: 'water_level'
+        });
+    }
+    /**
+     * Get tide predictions
+     */
+    async getTidePredictions(params) {
+        return this.fetchDataApi({
+            ...params,
+            product: 'predictions'
+        });
+    }
+    /**
+     * Get currents data
+     */
+    async getCurrents(params) {
+        return this.fetchDataApi({
+            ...params,
+            product: 'currents'
+        });
+    }
+    /**
+     * Get current predictions
+     */
+    async getCurrentPredictions(params) {
+        return this.fetchDataApi({
+            ...params,
+            product: 'currents_predictions'
+        });
+    }
+    /**
+     * Get meteorological data (air_temperature, wind, etc.)
+     */
+    async getMeteorologicalData(params) {
+        const { product, ...rest } = params;
+        return this.fetchDataApi({
+            ...rest,
+            product
+        });
+    }
+    /**
+     * Get list of stations
+     */
+    async getStations(params) {
+        const { type, name, lat_min, lat_max, lon_min, lon_max, state, limit, offset, sort_by, sort_order, ...rest } = params;
+        const endpoint = '/stations.' + (rest.format || 'json');
+        // Build query parameters with all the filters
+        const queryParams = { ...rest };
+        // Add filters only if they are defined
+        if (type)
+            queryParams.type = type;
+        if (name)
+            queryParams.name = name;
+        if (lat_min !== undefined)
+            queryParams.lat_min = lat_min;
+        if (lat_max !== undefined)
+            queryParams.lat_max = lat_max;
+        if (lon_min !== undefined)
+            queryParams.lon_min = lon_min;
+        if (lon_max !== undefined)
+            queryParams.lon_max = lon_max;
+        if (state)
+            queryParams.state = state;
+        if (limit !== undefined)
+            queryParams.limit = limit;
+        if (offset !== undefined)
+            queryParams.offset = offset;
+        if (sort_by)
+            queryParams.sort_by = sort_by;
+        if (sort_order)
+            queryParams.sort_order = sort_order;
+        return this.fetchMetadataApi(endpoint, queryParams);
+    }
+    /**
+     * Get station details
+     */
+    async getStationDetails(params) {
+        const { station, ...rest } = params;
+        const endpoint = `/stations/${station}/details.` + (rest.format || 'json');
+        return this.fetchMetadataApi(endpoint, rest);
+    }
+}

package/dist/schemas/common.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const StationSchema: z.ZodString;
+export declare const DateSchema: z.ZodOptional<z.ZodString>;
+export declare const BeginDateSchema: z.ZodOptional<z.ZodString>;
+export declare const EndDateSchema: z.ZodOptional<z.ZodString>;
+export declare const RangeSchema: z.ZodOptional<z.ZodNumber>;
+export declare const DatumSchema: z.ZodOptional<z.ZodString>;
+export declare const UnitsSchema: z.ZodOptional<z.ZodEnum<["english", "metric"]>>;
+export declare const TimeZoneSchema: z.ZodOptional<z.ZodEnum<["gmt", "lst", "lst_ldt"]>>;
+export declare const FormatSchema: z.ZodOptional<z.ZodEnum<["json", "xml", "csv"]>>;
+export declare const BinSchema: z.ZodOptional<z.ZodNumber>;
+export declare const IntervalSchema: z.ZodOptional<z.ZodString>;
+export declare const refineDateParams: (data: any) => any;
+export declare const dateRefinementMessage = "You must provide either 'date', 'begin_date' and 'end_date', 'begin_date' and 'range', 'end_date' and 'range', or just 'range'";

package/dist/schemas/common.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+// Common parameter schemas
+export const StationSchema = z.string().min(1).describe('Station ID');
+export const DateSchema = z.string().optional().describe('Date to retrieve data for ("today", "latest", "recent", or specific date)');
+export const BeginDateSchema = z.string().optional().describe('Start date (YYYYMMDD or MM/DD/YYYY)');
+export const EndDateSchema = z.string().optional().describe('End date (YYYYMMDD or MM/DD/YYYY)');
+export const RangeSchema = z.number().optional().describe('Number of hours to retrieve data for');
+export const DatumSchema = z.string().optional().describe('Datum to use (MLLW, MSL, etc.)');
+export const UnitsSchema = z.enum(['english', 'metric']).optional().describe('Units to use ("english" or "metric")');
+export const TimeZoneSchema = z.enum(['gmt', 'lst', 'lst_ldt']).optional().describe('Time zone (gmt, lst, lst_ldt)');
+export const FormatSchema = z.enum(['json', 'xml', 'csv']).optional().describe('Output format (json, xml, csv)');
+export const BinSchema = z.number().optional().describe('Bin number');
+export const IntervalSchema = z.string().optional().describe('Interval (hilo, hl, h, or a number for minutes)');
+// Schema refinement function for date parameters
+export const refineDateParams = (data) => (data.date || (data.begin_date && data.end_date) ||
+    (data.begin_date && data.range) || (data.end_date && data.range) ||
+    data.range);
+export const dateRefinementMessage = "You must provide either 'date', 'begin_date' and 'end_date', 'begin_date' and 'range', 'end_date' and 'range', or just 'range'";