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

package/dist/constants.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared constants for the NOAA Tides and Currents MCP server.
+ */
+/** NOAA CO-OPS Data Retrieval API (observations, predictions, currents, met). */
+export declare const DATA_API_BASE_URL = "https://api.tidesandcurrents.noaa.gov/api/prod/datagetter";
+/** NOAA CO-OPS Metadata API (station metadata, datums, harmonic constituents...). */
+export declare const METADATA_API_BASE_URL = "https://api.tidesandcurrents.noaa.gov/mdapi/prod/webapi";
+/** NOAA CO-OPS Derived Product API (sea level trends, high tide flooding...). */
+export declare const DPAPI_BASE_URL = "https://api.tidesandcurrents.noaa.gov/dpapi/prod";
+/**
+ * Sent as the `application` parameter on every Data API call so NOAA can
+ * attribute traffic in their logs (not an API key; the API is open).
+ */
+export declare const APPLICATION_NAME = "noaa-tides-currents-mcp-server";
+export declare const SERVER_NAME = "noaa-tides-currents-mcp-server";
+/** Maximum characters returned by a single tool response before truncation. */
+export declare const CHARACTER_LIMIT = 25000;
+/** HTTP request timeout in milliseconds. */
+export declare const REQUEST_TIMEOUT_MS = 30000;
+/** Number of retries for transient failures (network errors, 5xx, 429). */
+export declare const MAX_RETRIES = 2;
+/** Cache TTLs (milliseconds). */
+export declare const CACHE_TTL: {
+    /** Full station directory listings change rarely. */
+    readonly stationList: number;
+    /** Individual station metadata (datums, sensors, harcon...). */
+    readonly stationResource: number;
+};

package/dist/constants.js

@@ -0,0 +1,28 @@
+/**
+ * Shared constants for the NOAA Tides and Currents MCP server.
+ */
+/** NOAA CO-OPS Data Retrieval API (observations, predictions, currents, met). */
+export const DATA_API_BASE_URL = "https://api.tidesandcurrents.noaa.gov/api/prod/datagetter";
+/** NOAA CO-OPS Metadata API (station metadata, datums, harmonic constituents...). */
+export const METADATA_API_BASE_URL = "https://api.tidesandcurrents.noaa.gov/mdapi/prod/webapi";
+/** NOAA CO-OPS Derived Product API (sea level trends, high tide flooding...). */
+export const DPAPI_BASE_URL = "https://api.tidesandcurrents.noaa.gov/dpapi/prod";
+/**
+ * Sent as the `application` parameter on every Data API call so NOAA can
+ * attribute traffic in their logs (not an API key; the API is open).
+ */
+export const APPLICATION_NAME = "noaa-tides-currents-mcp-server";
+export const SERVER_NAME = "noaa-tides-currents-mcp-server";
+/** Maximum characters returned by a single tool response before truncation. */
+export const CHARACTER_LIMIT = 25_000;
+/** HTTP request timeout in milliseconds. */
+export const REQUEST_TIMEOUT_MS = 30_000;
+/** Number of retries for transient failures (network errors, 5xx, 429). */
+export const MAX_RETRIES = 2;
+/** Cache TTLs (milliseconds). */
+export const CACHE_TTL = {
+    /** Full station directory listings change rarely. */
+    stationList: 6 * 60 * 60 * 1000,
+    /** Individual station metadata (datums, sensors, harcon...). */
+    stationResource: 60 * 60 * 1000,
+};

package/dist/format/respond.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Response shaping shared by every tool.
+ *
+ * Each tool supports `response_format`: "markdown" (default, human-readable
+ * tables with units spelled out) or "json" (complete structured payload).
+ * Structured content is attached in both modes so MCP clients that support
+ * it can consume typed output. Responses longer than CHARACTER_LIMIT are
+ * truncated with guidance rather than flooding the agent's context.
+ */
+export type ResponseFormat = "markdown" | "json";
+export interface ToolResult {
+    [key: string]: unknown;
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    structuredContent?: Record<string, unknown>;
+    isError?: boolean;
+}
+/** Build a successful tool response in the requested format. */
+export declare function respond(format: ResponseFormat, structured: Record<string, unknown>, markdown: string): ToolResult;
+/** Build an error tool response (kept inside the result per MCP guidance). */
+export declare function respondError(error: unknown): ToolResult;
+/** Render an array of records as a compact GitHub-flavored markdown table. */
+export declare function markdownTable(headers: string[], rows: Array<Array<string | number | null | undefined>>): string;

package/dist/format/respond.js

@@ -0,0 +1,40 @@
+/**
+ * Response shaping shared by every tool.
+ *
+ * Each tool supports `response_format`: "markdown" (default, human-readable
+ * tables with units spelled out) or "json" (complete structured payload).
+ * Structured content is attached in both modes so MCP clients that support
+ * it can consume typed output. Responses longer than CHARACTER_LIMIT are
+ * truncated with guidance rather than flooding the agent's context.
+ */
+import { CHARACTER_LIMIT } from "../constants.js";
+/** Build a successful tool response in the requested format. */
+export function respond(format, structured, markdown) {
+    let text = format === "json" ? JSON.stringify(structured, null, 2) : markdown;
+    if (text.length > CHARACTER_LIMIT) {
+        text =
+            text.slice(0, CHARACTER_LIMIT) +
+                "\n\n…[truncated: response exceeded the size limit. Narrow the date range, lower the limit parameter, or request fewer fields.]";
+    }
+    return {
+        content: [{ type: "text", text }],
+        structuredContent: structured,
+    };
+}
+/** Build an error tool response (kept inside the result per MCP guidance). */
+export function respondError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+        isError: true,
+        content: [{ type: "text", text: `Error: ${message}` }],
+    };
+}
+/** Render an array of records as a compact GitHub-flavored markdown table. */
+export function markdownTable(headers, rows) {
+    const lines = [
+        `| ${headers.join(" | ")} |`,
+        `|${headers.map(() => "---").join("|")}|`,
+        ...rows.map((row) => `| ${row.map((cell) => (cell === null || cell === undefined || cell === "" ? "—" : String(cell))).join(" | ")} |`),
+    ];
+    return lines.join("\n");
+}

package/dist/format/series.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Markdown rendering for time-series tool responses: a metadata header
+ * (station, units, datum, time zone, count) followed by a data table and an
+ * optional flag legend, so units and quality semantics are always visible.
+ */
+export interface SeriesMeta {
+    title: string;
+    station: string;
+    stationName?: string;
+    unitsLabel?: string;
+    datum?: string;
+    timeZone?: string;
+    extra?: string[];
+}
+export declare function seriesMarkdown(meta: SeriesMeta, headers: string[], rows: Array<Array<string | number | null | undefined>>, legend?: string): string;
+export declare function timeZoneLabel(tz: string): string;

package/dist/format/series.js

@@ -0,0 +1,42 @@
+/**
+ * Markdown rendering for time-series tool responses: a metadata header
+ * (station, units, datum, time zone, count) followed by a data table and an
+ * optional flag legend, so units and quality semantics are always visible.
+ */
+import { markdownTable } from "./respond.js";
+export function seriesMarkdown(meta, headers, rows, legend) {
+    const lines = [`# ${meta.title}`, ""];
+    const facts = [
+        `**Station**: ${meta.station}${meta.stationName ? ` (${meta.stationName})` : ""}`,
+    ];
+    if (meta.unitsLabel)
+        facts.push(`**Units**: ${meta.unitsLabel}`);
+    if (meta.datum)
+        facts.push(`**Datum**: ${meta.datum}`);
+    if (meta.timeZone)
+        facts.push(`**Time zone**: ${meta.timeZone}`);
+    facts.push(`**Records**: ${rows.length}`);
+    lines.push(facts.join(" · "));
+    if (meta.extra?.length) {
+        lines.push("", ...meta.extra);
+    }
+    lines.push("");
+    if (rows.length === 0) {
+        lines.push("_No data returned for this request. The station may not collect this product, or the window may fall outside its record — check noaa_get_station_info._");
+    }
+    else {
+        lines.push(markdownTable(headers, rows));
+    }
+    if (legend && rows.length > 0) {
+        lines.push("", `_${legend}_`);
+    }
+    return lines.join("\n");
+}
+const TIME_ZONE_LABELS = {
+    gmt: "GMT (UTC)",
+    lst: "local standard time (no DST)",
+    lst_ldt: "local time (DST-aware)",
+};
+export function timeZoneLabel(tz) {
+    return TIME_ZONE_LABELS[tz] ?? tz;
+}

package/dist/format/units.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Unit labeling for NOAA CO-OPS measurements.
+ *
+ * The `units` request parameter (english|metric) changes the physical units
+ * per measurement type — and NOT uniformly:
+ *   - wind speed:    english = knots, metric = m/s
+ *   - current speed: english = knots, metric = cm/s   (NOT m/s!)
+ *   - air pressure:  millibars in BOTH systems
+ *   - salinity:      PSU in BOTH systems
+ * Every tool response labels its values so the agent never has to guess.
+ */
+export type UnitSystem = "english" | "metric";
+export type MeasurementKind = "water_level" | "air_temperature" | "water_temperature" | "wind" | "air_pressure" | "air_gap" | "conductivity" | "visibility" | "humidity" | "salinity" | "currents";
+export declare function unitLabel(kind: MeasurementKind, units: UnitSystem): string;
+/** Quality/data flags per product family, decoded for humans. */
+export declare const FLAG_LEGENDS: Record<string, string>;

package/dist/format/units.js

@@ -0,0 +1,37 @@
+/**
+ * Unit labeling for NOAA CO-OPS measurements.
+ *
+ * The `units` request parameter (english|metric) changes the physical units
+ * per measurement type — and NOT uniformly:
+ *   - wind speed:    english = knots, metric = m/s
+ *   - current speed: english = knots, metric = cm/s   (NOT m/s!)
+ *   - air pressure:  millibars in BOTH systems
+ *   - salinity:      PSU in BOTH systems
+ * Every tool response labels its values so the agent never has to guess.
+ */
+const UNIT_LABELS = {
+    water_level: { english: "feet", metric: "meters" },
+    air_temperature: { english: "°F", metric: "°C" },
+    water_temperature: { english: "°F", metric: "°C" },
+    wind: { english: "knots", metric: "m/s" },
+    air_pressure: { english: "millibars", metric: "millibars" },
+    air_gap: { english: "feet", metric: "meters" },
+    conductivity: { english: "mS/cm", metric: "mS/cm" },
+    visibility: { english: "nautical miles", metric: "kilometers" },
+    humidity: { english: "%", metric: "%" },
+    salinity: { english: "PSU", metric: "PSU" },
+    currents: { english: "knots", metric: "cm/s" },
+};
+export function unitLabel(kind, units) {
+    return UNIT_LABELS[kind][units];
+}
+/** Quality/data flags per product family, decoded for humans. */
+export const FLAG_LEGENDS = {
+    water_level_preliminary: "f flags (count of 1-sec samples flagged): O=outside 3-sigma band, F=flat tolerance exceeded, R=rate-of-change limit exceeded, L=max/min limit exceeded",
+    water_level_verified: "f flags: I=inferred value, F=flat tolerance exceeded, R=rate-of-change limit exceeded, T=max/min limit exceeded",
+    hourly_height: "f flags: I=inferred, L=max/min limit exceeded",
+    high_low: "f flags: I=inferred, L=max/min limit exceeded; ty: HH=higher high, H=high, L=low, LL=lower low",
+    met: "f flags: X=max limit exceeded, N=min limit exceeded, R=rate-of-change limit exceeded",
+    wind: "f flags: X=max wind speed exceeded, R=rate-of-change limit exceeded",
+    air_gap: "f flags: O=outside 3-sigma band, F=flat tolerance exceeded, R=rate-of-change exceeded, A=max/min limit exceeded",
+};

package/dist/index.d.ts

@@ -1,2 +1,16 @@
 #!/usr/bin/env node
+/**
+ * NOAA Tides and Currents MCP server.
+ *
+ * Exposes NOAA CO-OPS data (water levels, tide predictions, currents,
+ * meteorology), station metadata (datums, harmonic constituents, offsets),
+ * derived products (sea level trends/projections, extreme water levels,
+ * high tide flooding), and local sun/moon calculations.
+ *
+ * Transport: stdio by default (for MCP client integration); pass --http
+ * [--port N] for a stateless streamable-HTTP endpoint at /mcp.
+ *
+ * IMPORTANT: never write to stdout in stdio mode — it is the JSON-RPC
+ * channel. All logging goes to stderr.
+ */
 export {};

package/dist/index.js

@@ -1,9 +1,79 @@
 #!/usr/bin/env node
-import { createServer, startServer } from './server/config.js';
-import { registerAllTools } from './tools/index.js';
-// Create and configure the MCP server
-const server = createServer();
-// Register all tools
-const services = registerAllTools(server);
-// Start the server
-startServer(server);
+/**
+ * NOAA Tides and Currents MCP server.
+ *
+ * Exposes NOAA CO-OPS data (water levels, tide predictions, currents,
+ * meteorology), station metadata (datums, harmonic constituents, offsets),
+ * derived products (sea level trends/projections, extreme water levels,
+ * high tide flooding), and local sun/moon calculations.
+ *
+ * Transport: stdio by default (for MCP client integration); pass --http
+ * [--port N] for a stateless streamable-HTTP endpoint at /mcp.
+ *
+ * IMPORTANT: never write to stdout in stdio mode — it is the JSON-RPC
+ * channel. All logging goes to stderr.
+ */
+import { createRequire } from "node:module";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import express from "express";
+import { SERVER_NAME } from "./constants.js";
+import { registerAllTools } from "./tools/index.js";
+import { registerResources } from "./resources/index.js";
+import { registerPrompts } from "./prompts/index.js";
+const require = createRequire(import.meta.url);
+const { version } = require("../package.json");
+function buildServer() {
+    const server = new McpServer({ name: SERVER_NAME, version });
+    registerAllTools(server);
+    registerResources(server);
+    registerPrompts(server);
+    return server;
+}
+async function runStdio() {
+    const server = buildServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`${SERVER_NAME} v${version} running on stdio`);
+}
+async function runHttp(port) {
+    const app = express();
+    app.use(express.json());
+    app.post("/mcp", async (req, res) => {
+        // Stateless: a fresh server+transport per request avoids request-ID
+        // collisions across clients.
+        const server = buildServer();
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: undefined,
+            enableJsonResponse: true,
+        });
+        res.on("close", () => {
+            void transport.close();
+            void server.close();
+        });
+        await server.connect(transport);
+        await transport.handleRequest(req, res, req.body);
+    });
+    app.listen(port, () => {
+        console.error(`${SERVER_NAME} v${version} running at http://localhost:${port}/mcp`);
+    });
+}
+const args = process.argv.slice(2);
+if (args.includes("--http")) {
+    const portIndex = args.indexOf("--port");
+    const portRaw = portIndex !== -1 ? Number(args[portIndex + 1]) : 3000;
+    const port = Number.isInteger(portRaw) && portRaw > 0 && portRaw < 65536
+        ? portRaw
+        : 3000;
+    runHttp(port).catch((error) => {
+        console.error("Server error:", error);
+        process.exit(1);
+    });
+}
+else {
+    runStdio().catch((error) => {
+        console.error("Server error:", error);
+        process.exit(1);
+    });
+}

package/dist/interfaces/moon.d.ts

@@ -1,5 +1,5 @@
-import { z } from 'zod';
-import { MoonPhaseName } from '../types/moon.js';
+import { z } from "zod";
+import { MoonPhaseName } from "../types/moon.js";
 /**
  * Parameters for getting moon phase
  */
@@ -30,14 +30,14 @@ export declare const MoonPhasesRangeParamsSchema: z.ZodObject<{
     longitude: z.ZodOptional<z.ZodNumber>;
     format: z.ZodOptional<z.ZodEnum<["json", "text"]>>;
 }, "strip", z.ZodTypeAny, {
-    start_date: string;
     end_date: string;
+    start_date: string;
     format?: "text" | "json" | undefined;
     latitude?: number | undefined;
     longitude?: number | undefined;
 }, {
-    start_date: string;
     end_date: string;
+    start_date: string;
     format?: "text" | "json" | undefined;
     latitude?: number | undefined;
     longitude?: number | undefined;

package/dist/interfaces/moon.js

@@ -1,35 +1,76 @@
-import { z } from 'zod';
-import { MoonPhaseName } from '../types/moon.js';
+import { z } from "zod";
+import { MoonPhaseName } from "../types/moon.js";
 /**
  * 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)')
+    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)')
+    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([
+    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)')
+        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)"),
 });

package/dist/interfaces/sun.d.ts

@@ -1,5 +1,5 @@
-import { z } from 'zod';
-import { SunEventType } from '../types/sun.js';
+import { z } from "zod";
+import { SunEventType } from "../types/sun.js";
 /**
  * Parameters for getting sun times
  */
@@ -34,17 +34,17 @@ export declare const SunTimesRangeParamsSchema: z.ZodObject<{
     format: z.ZodOptional<z.ZodEnum<["json", "text"]>>;
     timezone: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    end_date: string;
     latitude: number;
     longitude: number;
     start_date: string;
-    end_date: string;
     format?: "text" | "json" | undefined;
     timezone?: string | undefined;
 }, {
+    end_date: string;
     latitude: number;
     longitude: number;
     start_date: string;
-    end_date: string;
     format?: "text" | "json" | undefined;
     timezone?: string | undefined;
 }>;

package/dist/interfaces/sun.js

@@ -1,45 +1,114 @@
-import { z } from 'zod';
-import { SunEventType } from '../types/sun.js';
+import { z } from "zod";
+import { SunEventType } from "../types/sun.js";
 /**
  * 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.')
+    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.')
+    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)')
+    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.')
+    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."),
 });

package/dist/prompts/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * MCP prompts: reusable workflow templates that orchestrate the server's
+ * tools for the most common NOAA questions.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerPrompts(server: McpServer): void;