@cyanheads/noaa-marine-mcp-server 0.1.1

package/dist/config/server-config.js

@@ -0,0 +1,20 @@
+/**
+ * @fileoverview Server-specific environment variable configuration for noaa-marine-mcp-server.
+ * @module config/server-config
+ */
+import { z } from '@cyanheads/mcp-ts-core';
+import { parseEnvConfig } from '@cyanheads/mcp-ts-core/config';
+const ServerConfigSchema = z.object({
+    applicationId: z
+        .string()
+        .default('noaa-marine-mcp-server')
+        .describe('Courtesy identifier sent as application= on CO-OPS requests.'),
+});
+let _config;
+export function getServerConfig() {
+    _config ??= parseEnvConfig(ServerConfigSchema, {
+        applicationId: 'NOAA_APPLICATION_ID',
+    });
+    return _config;
+}
+//# sourceMappingURL=server-config.js.map

package/dist/config/server-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-config.js","sourceRoot":"","sources":["../../src/config/server-config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IAClC,aAAa,EAAE,CAAC;SACb,MAAM,EAAE;SACR,OAAO,CAAC,wBAAwB,CAAC;SACjC,QAAQ,CAAC,8DAA8D,CAAC;CAC5E,CAAC,CAAC;AAIH,IAAI,OAAiC,CAAC;AAEtC,MAAM,UAAU,eAAe;IAC7B,OAAO,KAAK,cAAc,CAAC,kBAAkB,EAAE;QAC7C,aAAa,EAAE,qBAAqB;KACrC,CAAC,CAAC;IACH,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * @fileoverview noaa-marine-mcp-server MCP server entry point.
+ * @module index
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA;;;GAGG"}

package/dist/index.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+/**
+ * @fileoverview noaa-marine-mcp-server MCP server entry point.
+ * @module index
+ */
+import { createApp } from '@cyanheads/mcp-ts-core';
+import { getServerConfig } from './config/server-config.js';
+import { noaaMarineStationResource } from './mcp-server/resources/definitions/noaa-marine-station.resource.js';
+import { noaaMarineFindStations } from './mcp-server/tools/definitions/noaa-marine-find-stations.tool.js';
+import { noaaMarineGetConditions } from './mcp-server/tools/definitions/noaa-marine-get-conditions.tool.js';
+import { noaaMarineGetCurrents } from './mcp-server/tools/definitions/noaa-marine-get-currents.tool.js';
+import { noaaMarineGetTidePredictions } from './mcp-server/tools/definitions/noaa-marine-get-tide-predictions.tool.js';
+import { noaaMarineGetWaterLevel } from './mcp-server/tools/definitions/noaa-marine-get-water-level.tool.js';
+import { initCoopsService } from './services/coops/coops-service.js';
+import { initNdbcService } from './services/ndbc/ndbc-service.js';
+await createApp({
+    tools: [
+        noaaMarineFindStations,
+        noaaMarineGetTidePredictions,
+        noaaMarineGetWaterLevel,
+        noaaMarineGetCurrents,
+        noaaMarineGetConditions,
+    ],
+    resources: [noaaMarineStationResource],
+    prompts: [],
+    instructions: 'US marine conditions via NOAA CO-OPS and NDBC. ' +
+        'Start with noaa_marine_find_stations to resolve a location or name to station IDs, ' +
+        'then call the appropriate data tool. ' +
+        'CO-OPS provides tide predictions (noaa_marine_get_tide_predictions), ' +
+        'observed water levels and storm surge (noaa_marine_get_water_level), ' +
+        'and tidal current predictions (noaa_marine_get_currents). ' +
+        'NDBC provides live buoy conditions — waves, wind, sea-surface temp (noaa_marine_get_conditions). ' +
+        'All water height data is referenced to MLLW by default (US nautical chart datum).',
+    setup(core) {
+        const serverConfig = getServerConfig();
+        initCoopsService(core.config, core.storage, serverConfig);
+        initNdbcService();
+    },
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,yBAAyB,EAAE,MAAM,oEAAoE,CAAC;AAC/G,OAAO,EAAE,sBAAsB,EAAE,MAAM,kEAAkE,CAAC;AAC1G,OAAO,EAAE,uBAAuB,EAAE,MAAM,mEAAmE,CAAC;AAC5G,OAAO,EAAE,qBAAqB,EAAE,MAAM,iEAAiE,CAAC;AACxG,OAAO,EAAE,4BAA4B,EAAE,MAAM,yEAAyE,CAAC;AACvH,OAAO,EAAE,uBAAuB,EAAE,MAAM,oEAAoE,CAAC;AAC7G,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAElE,MAAM,SAAS,CAAC;IACd,KAAK,EAAE;QACL,sBAAsB;QACtB,4BAA4B;QAC5B,uBAAuB;QACvB,qBAAqB;QACrB,uBAAuB;KACxB;IACD,SAAS,EAAE,CAAC,yBAAyB,CAAC;IACtC,OAAO,EAAE,EAAE;IACX,YAAY,EACV,iDAAiD;QACjD,qFAAqF;QACrF,uCAAuC;QACvC,uEAAuE;QACvE,uEAAuE;QACvE,4DAA4D;QAC5D,mGAAmG;QACnG,mFAAmF;IAErF,KAAK,CAAC,IAAI;QACR,MAAM,YAAY,GAAG,eAAe,EAAE,CAAC;QACvC,gBAAgB,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;QAC1D,eAAe,EAAE,CAAC;IACpB,CAAC;CACF,CAAC,CAAC"}

package/dist/mcp-server/resources/definitions/noaa-marine-station.resource.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview noaa-marine://station/{station_id} resource — metadata for a CO-OPS or NDBC station.
+ * @module mcp-server/resources/definitions/noaa-marine-station.resource
+ */
+import { z } from '@cyanheads/mcp-ts-core';
+export declare const noaaMarineStationResource: import("@cyanheads/mcp-ts-core").ResourceDefinition<z.ZodObject<{
+    station_id: z.ZodString;
+}, z.core.$strip>, undefined, undefined>;
+//# sourceMappingURL=noaa-marine-station.resource.d.ts.map

package/dist/mcp-server/resources/definitions/noaa-marine-station.resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noaa-marine-station.resource.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/resources/definitions/noaa-marine-station.resource.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAY,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAKrD,eAAO,MAAM,yBAAyB;;wCA0FpC,CAAC"}

package/dist/mcp-server/resources/definitions/noaa-marine-station.resource.js

@@ -0,0 +1,96 @@
+/**
+ * @fileoverview noaa-marine://station/{station_id} resource — metadata for a CO-OPS or NDBC station.
+ * @module mcp-server/resources/definitions/noaa-marine-station.resource
+ */
+import { resource, z } from '@cyanheads/mcp-ts-core';
+import { notFound } from '@cyanheads/mcp-ts-core/errors';
+import { getCoopsService } from '../../../services/coops/coops-service.js';
+import { getNdbcService } from '../../../services/ndbc/ndbc-service.js';
+export const noaaMarineStationResource = resource('noaa-marine://station/{station_id}', {
+    name: 'noaa_marine_station',
+    description: 'Metadata for a CO-OPS or NDBC station by ID: name, coordinates, source, capabilities, and state. ' +
+        'CO-OPS station IDs are numeric (tide/water-level) or alphanumeric (current stations). ' +
+        'NDBC station IDs are 5-character alphanumeric codes. ' +
+        'Use noaa_marine_find_stations to discover station IDs.',
+    mimeType: 'application/json',
+    params: z.object({
+        station_id: z
+            .string()
+            .regex(/^[A-Za-z0-9_-]{1,20}$/)
+            .describe('Station identifier. CO-OPS: numeric (e.g. 9447130) or alphanumeric (e.g. ACT4176). NDBC: e.g. 46041.'),
+    }),
+    async handler(params, ctx) {
+        const coopsSvc = getCoopsService();
+        const ndbcSvc = getNdbcService();
+        const id = params.station_id.toUpperCase();
+        // Search CO-OPS lists and NDBC in parallel
+        const [coopsResult, ndbcResult] = await Promise.allSettled([
+            Promise.all([
+                coopsSvc.getStations('tidepredictions', ctx),
+                coopsSvc.getStations('currentpredictions', ctx),
+                coopsSvc.getStations('waterlevels', ctx),
+            ]),
+            ndbcSvc.getActiveStations(ctx),
+        ]);
+        // Check CO-OPS
+        if (coopsResult.status === 'fulfilled') {
+            const [tide, current, waterLevel] = coopsResult.value;
+            const match = tide.find((s) => s.id.toUpperCase() === id) ??
+                current.find((s) => s.id.toUpperCase() === id) ??
+                waterLevel.find((s) => s.id.toUpperCase() === id);
+            if (match) {
+                const caps = [];
+                if (tide.some((s) => s.id.toUpperCase() === id))
+                    caps.push('tide');
+                if (current.some((s) => s.id.toUpperCase() === id))
+                    caps.push('current');
+                if (waterLevel.some((s) => s.id.toUpperCase() === id))
+                    caps.push('water_level');
+                if (caps.length === 0)
+                    caps.push('tide');
+                const result = {
+                    station_id: match.id,
+                    name: match.name,
+                    source: 'coops',
+                    latitude: match.lat,
+                    longitude: match.lng,
+                    capabilities: caps,
+                };
+                if (match.state)
+                    result.state = match.state;
+                if (match.type)
+                    result.type = match.type;
+                return result;
+            }
+        }
+        // Check NDBC
+        if (ndbcResult.status === 'fulfilled') {
+            const match = ndbcResult.value.find((s) => s.id.toUpperCase() === id);
+            if (match) {
+                const caps = [];
+                if (match.hasMet)
+                    caps.push('met');
+                if (match.hasCurrents)
+                    caps.push('currents');
+                if (caps.length === 0)
+                    caps.push('buoy');
+                const result = {
+                    station_id: match.id,
+                    name: match.name,
+                    source: 'ndbc',
+                    latitude: match.lat,
+                    longitude: match.lon,
+                    type: match.type ?? 'buoy',
+                    capabilities: caps,
+                };
+                if (match.owner)
+                    result.owner = match.owner;
+                return result;
+            }
+        }
+        throw notFound(`Station ${params.station_id} not found in CO-OPS or NDBC. Use noaa_marine_find_stations to discover valid IDs.`, {
+            station_id: params.station_id,
+        });
+    },
+});
+//# sourceMappingURL=noaa-marine-station.resource.js.map

package/dist/mcp-server/resources/definitions/noaa-marine-station.resource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"noaa-marine-station.resource.js","sourceRoot":"","sources":["../../../../src/mcp-server/resources/definitions/noaa-marine-station.resource.ts"],"names":[],"mappings":"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"}

package/dist/mcp-server/tools/definitions/noaa-marine-find-stations.tool.d.ts

@@ -0,0 +1,105 @@
+/**
+ * @fileoverview noaa_marine_find_stations tool — multi-source station discovery for CO-OPS and NDBC.
+ * @module mcp-server/tools/definitions/noaa-marine-find-stations.tool
+ */
+import { z } from '@cyanheads/mcp-ts-core';
+import { JsonRpcErrorCode } from '@cyanheads/mcp-ts-core/errors';
+export declare const noaaMarineFindStations: import("@cyanheads/mcp-ts-core").ToolDefinition<z.ZodObject<{
+    latitude: z.ZodOptional<z.ZodNumber>;
+    longitude: z.ZodOptional<z.ZodNumber>;
+    radius_km: z.ZodDefault<z.ZodNumber>;
+    query: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodEnum<{
+        ID: "ID";
+        AL: "AL";
+        AK: "AK";
+        AZ: "AZ";
+        AR: "AR";
+        CA: "CA";
+        CO: "CO";
+        CT: "CT";
+        DE: "DE";
+        FL: "FL";
+        GA: "GA";
+        HI: "HI";
+        IL: "IL";
+        IN: "IN";
+        IA: "IA";
+        KS: "KS";
+        KY: "KY";
+        LA: "LA";
+        ME: "ME";
+        MD: "MD";
+        MA: "MA";
+        MI: "MI";
+        MN: "MN";
+        MS: "MS";
+        MO: "MO";
+        MT: "MT";
+        NE: "NE";
+        NV: "NV";
+        NH: "NH";
+        NJ: "NJ";
+        NM: "NM";
+        NY: "NY";
+        NC: "NC";
+        ND: "ND";
+        OH: "OH";
+        OK: "OK";
+        OR: "OR";
+        PA: "PA";
+        RI: "RI";
+        SC: "SC";
+        SD: "SD";
+        TN: "TN";
+        TX: "TX";
+        UT: "UT";
+        VT: "VT";
+        VA: "VA";
+        WA: "WA";
+        WV: "WV";
+        WI: "WI";
+        WY: "WY";
+        DC: "DC";
+        PR: "PR";
+        VI: "VI";
+        GU: "GU";
+        AS: "AS";
+        MP: "MP";
+    }>>;
+    source: z.ZodDefault<z.ZodEnum<{
+        coops: "coops";
+        ndbc: "ndbc";
+        all: "all";
+    }>>;
+    types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        water_level: "water_level";
+        met: "met";
+        tide: "tide";
+        current: "current";
+        buoy: "buoy";
+    }>>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    stations: z.ZodArray<z.ZodObject<{
+        station_id: z.ZodString;
+        name: z.ZodString;
+        source: z.ZodEnum<{
+            coops: "coops";
+            ndbc: "ndbc";
+        }>;
+        type: z.ZodString;
+        latitude: z.ZodNumber;
+        longitude: z.ZodNumber;
+        distance_km: z.ZodOptional<z.ZodNumber>;
+        state: z.ZodOptional<z.ZodString>;
+        capabilities: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    total_found: z.ZodNumber;
+}, z.core.$strip>, readonly [{
+    readonly reason: "no_results";
+    readonly code: JsonRpcErrorCode.NotFound;
+    readonly when: "No stations match the query, location, or filters.";
+    readonly recovery: "Widen the search by increasing radius_km, removing type filters, or using a broader query.";
+}], undefined>;
+//# sourceMappingURL=noaa-marine-find-stations.tool.d.ts.map

package/dist/mcp-server/tools/definitions/noaa-marine-find-stations.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noaa-marine-find-stations.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/noaa-marine-find-stations.tool.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AA0EjE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiUjC,CAAC"}

package/dist/mcp-server/tools/definitions/noaa-marine-find-stations.tool.js

@@ -0,0 +1,338 @@
+/**
+ * @fileoverview noaa_marine_find_stations tool — multi-source station discovery for CO-OPS and NDBC.
+ * @module mcp-server/tools/definitions/noaa-marine-find-stations.tool
+ */
+import { tool, z } from '@cyanheads/mcp-ts-core';
+import { JsonRpcErrorCode } from '@cyanheads/mcp-ts-core/errors';
+import { getCoopsService } from '../../../services/coops/coops-service.js';
+import { getNdbcService } from '../../../services/ndbc/ndbc-service.js';
+/** Haversine distance in km between two lat/lon pairs. */
+function haversineKm(lat1, lon1, lat2, lon2) {
+    const R = 6371;
+    const dLat = ((lat2 - lat1) * Math.PI) / 180;
+    const dLon = ((lon2 - lon1) * Math.PI) / 180;
+    const a = Math.sin(dLat / 2) ** 2 +
+        Math.cos((lat1 * Math.PI) / 180) * Math.cos((lat2 * Math.PI) / 180) * Math.sin(dLon / 2) ** 2;
+    return R * 2 * Math.asin(Math.sqrt(a));
+}
+const STATE_CODES = [
+    'AL',
+    'AK',
+    'AZ',
+    'AR',
+    'CA',
+    'CO',
+    'CT',
+    'DE',
+    'FL',
+    'GA',
+    'HI',
+    'ID',
+    'IL',
+    'IN',
+    'IA',
+    'KS',
+    'KY',
+    'LA',
+    'ME',
+    'MD',
+    'MA',
+    'MI',
+    'MN',
+    'MS',
+    'MO',
+    'MT',
+    'NE',
+    'NV',
+    'NH',
+    'NJ',
+    'NM',
+    'NY',
+    'NC',
+    'ND',
+    'OH',
+    'OK',
+    'OR',
+    'PA',
+    'RI',
+    'SC',
+    'SD',
+    'TN',
+    'TX',
+    'UT',
+    'VT',
+    'VA',
+    'WA',
+    'WV',
+    'WI',
+    'WY',
+    'DC',
+    'PR',
+    'VI',
+    'GU',
+    'AS',
+    'MP',
+];
+export const noaaMarineFindStations = tool('noaa_marine_find_stations', {
+    title: 'Find Marine Stations',
+    description: 'Find CO-OPS tide/water-level/current stations and NDBC buoys near a location or by name/state. ' +
+        'Returns a unified station list with source, type, capabilities, and coordinates. ' +
+        'This is the required first step to resolve place names or coordinates to station IDs before calling data tools. ' +
+        'CO-OPS station IDs are numeric (e.g. 9447130 for Seattle); current station IDs are alphanumeric (e.g. ACT4176). ' +
+        'NDBC buoy IDs are 5-character alphanumeric codes (e.g. 46041). ' +
+        'Provide latitude/longitude for proximity search, or query/state for name-based search — both may be combined.',
+    annotations: { readOnlyHint: true, openWorldHint: true },
+    input: z.object({
+        latitude: z
+            .number()
+            .min(-90)
+            .max(90)
+            .optional()
+            .describe('Center latitude in decimal degrees for proximity search. Pair with longitude and optionally radius_km.'),
+        longitude: z
+            .number()
+            .min(-180)
+            .max(180)
+            .optional()
+            .describe('Center longitude in decimal degrees for proximity search. Pair with latitude and optionally radius_km.'),
+        radius_km: z
+            .number()
+            .min(1)
+            .max(1000)
+            .default(100)
+            .describe('Search radius in kilometers when latitude/longitude are provided. Defaults to 100 km.'),
+        query: z
+            .string()
+            .optional()
+            .describe('Station name substring to search (case-insensitive token match). E.g. "seattle", "puget sound".'),
+        state: z
+            .enum(STATE_CODES)
+            .optional()
+            .describe('Filter by 2-letter US state or territory code (CO-OPS stations only). E.g. "WA", "CA", "PR".'),
+        source: z
+            .enum(['coops', 'ndbc', 'all'])
+            .default('all')
+            .describe('Data source to search: coops (tide/water-level/current stations), ndbc (buoys), or all (default).'),
+        types: z
+            .array(z
+            .enum(['tide', 'current', 'water_level', 'buoy', 'met'])
+            .describe('Station capability type: tide (CO-OPS tide predictions), current (CO-OPS current predictions), ' +
+            'water_level (CO-OPS observed water levels), buoy (NDBC buoy), met (NDBC meteorological).'))
+            .optional()
+            .describe('Filter by station type/capability. Omit to return all types.'),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(200)
+            .default(20)
+            .describe('Maximum number of stations to return. Defaults to 20.'),
+    }),
+    output: z.object({
+        stations: z
+            .array(z
+            .object({
+            station_id: z.string().describe('Station identifier — use this ID with data tools.'),
+            name: z.string().describe('Station name.'),
+            source: z
+                .enum(['coops', 'ndbc'])
+                .describe('Data source: coops (CO-OPS) or ndbc (NDBC buoy).'),
+            type: z
+                .string()
+                .describe('Station type/capability string, e.g. "tide", "current", "water_level", "buoy".'),
+            latitude: z.number().describe('Station latitude in decimal degrees.'),
+            longitude: z.number().describe('Station longitude in decimal degrees.'),
+            distance_km: z
+                .number()
+                .optional()
+                .describe('Distance in km from the search center (only present when lat/lon search was used).'),
+            state: z
+                .string()
+                .optional()
+                .describe('US state or territory code (CO-OPS stations only).'),
+            capabilities: z
+                .array(z.string().describe('Capability identifier, e.g. "tide", "water_level".'))
+                .describe('List of data products available at this station.'),
+        })
+            .describe('A single station matching the search criteria.'))
+            .describe('Stations matching the search criteria, sorted by distance (if lat/lon provided) or name.'),
+        total_found: z
+            .number()
+            .describe('Total stations matching the filters before the limit was applied.'),
+    }),
+    errors: [
+        {
+            reason: 'no_results',
+            code: JsonRpcErrorCode.NotFound,
+            when: 'No stations match the query, location, or filters.',
+            recovery: 'Widen the search by increasing radius_km, removing type filters, or using a broader query.',
+        },
+    ],
+    async handler(input, ctx) {
+        const coopsSvc = getCoopsService();
+        const ndbcSvc = getNdbcService();
+        const results = [];
+        const lat = input.latitude;
+        const lon = input.longitude;
+        const hasLatLon = lat !== undefined && lat !== null && lon !== undefined && lon !== null;
+        // Fetch CO-OPS and NDBC lists in parallel
+        const includeCoops = input.source === 'all' || input.source === 'coops';
+        const includeNdbc = input.source === 'all' || input.source === 'ndbc';
+        const [coopsResults, ndbcResult] = await Promise.allSettled([
+            includeCoops
+                ? Promise.all([
+                    coopsSvc.getStations('tidepredictions', ctx),
+                    coopsSvc.getStations('currentpredictions', ctx),
+                    coopsSvc.getStations('waterlevels', ctx),
+                ])
+                : Promise.resolve(null),
+            includeNdbc ? ndbcSvc.getActiveStations(ctx) : Promise.resolve(null),
+        ]);
+        // Process CO-OPS stations
+        if (coopsResults.status === 'fulfilled' && coopsResults.value) {
+            const [tideStations, currentStations, waterLevelStations] = coopsResults.value;
+            const tideSet = new Set();
+            const currentSet = new Set();
+            const waterLevelSet = new Set();
+            for (const s of tideStations)
+                tideSet.add(s.id);
+            for (const s of currentStations)
+                currentSet.add(s.id);
+            for (const s of waterLevelStations)
+                waterLevelSet.add(s.id);
+            // Build unique station map — a station can appear in multiple lists
+            const allCoops = new Map();
+            for (const s of tideStations) {
+                if (!allCoops.has(s.id))
+                    allCoops.set(s.id, { ...s, capabilities: [] });
+                const entry = allCoops.get(s.id);
+                if (entry && !entry.capabilities.includes('tide'))
+                    entry.capabilities.push('tide');
+            }
+            for (const s of currentStations) {
+                if (!allCoops.has(s.id))
+                    allCoops.set(s.id, { ...s, capabilities: [] });
+                const entry = allCoops.get(s.id);
+                if (entry && !entry.capabilities.includes('current'))
+                    entry.capabilities.push('current');
+            }
+            for (const s of waterLevelStations) {
+                if (!allCoops.has(s.id))
+                    allCoops.set(s.id, { ...s, capabilities: [] });
+                const entry = allCoops.get(s.id);
+                if (entry && !entry.capabilities.includes('water_level'))
+                    entry.capabilities.push('water_level');
+            }
+            for (const [, s] of allCoops) {
+                // Apply type filter
+                if (input.types && input.types.length > 0) {
+                    const hasMatch = input.types.some((t) => (t === 'tide' && tideSet.has(s.id)) ||
+                        (t === 'current' && currentSet.has(s.id)) ||
+                        (t === 'water_level' && waterLevelSet.has(s.id)));
+                    if (!hasMatch)
+                        continue;
+                }
+                // Apply state filter
+                if (input.state && s.state !== input.state)
+                    continue;
+                // Apply name query
+                if (input.query) {
+                    const q = input.query.toLowerCase();
+                    if (!s.name.toLowerCase().includes(q))
+                        continue;
+                }
+                const primaryType = s.capabilities[0] ?? 'tide';
+                const entry = {
+                    station_id: s.id,
+                    name: s.name,
+                    source: 'coops',
+                    type: primaryType,
+                    latitude: s.lat,
+                    longitude: s.lng,
+                    capabilities: s.capabilities,
+                };
+                if (s.state)
+                    entry.state = s.state;
+                if (hasLatLon && lat !== undefined && lon !== undefined) {
+                    const dist = haversineKm(lat, lon, s.lat, s.lng);
+                    if (dist > input.radius_km)
+                        continue;
+                    entry.distance_km = Math.round(dist * 10) / 10;
+                }
+                results.push(entry);
+            }
+        }
+        // Process NDBC stations
+        if (ndbcResult.status === 'fulfilled' && ndbcResult.value) {
+            for (const s of ndbcResult.value) {
+                // Apply type filter
+                if (input.types && input.types.length > 0) {
+                    const hasMatch = input.types.some((t) => (t === 'buoy' || t === 'met') && (s.hasMet || s.type?.toLowerCase().includes('buoy')));
+                    if (!hasMatch)
+                        continue;
+                }
+                // Apply name query
+                if (input.query) {
+                    const q = input.query.toLowerCase();
+                    if (!s.name.toLowerCase().includes(q) && !s.id.toLowerCase().includes(q))
+                        continue;
+                }
+                const capabilities = [];
+                if (s.hasMet)
+                    capabilities.push('met');
+                if (s.hasCurrents)
+                    capabilities.push('currents');
+                if (capabilities.length === 0)
+                    capabilities.push('buoy');
+                const entry = {
+                    station_id: s.id,
+                    name: s.name,
+                    source: 'ndbc',
+                    type: 'buoy',
+                    latitude: s.lat,
+                    longitude: s.lon,
+                    capabilities,
+                };
+                if (hasLatLon && lat !== undefined && lon !== undefined) {
+                    const dist = haversineKm(lat, lon, s.lat, s.lon);
+                    if (dist > input.radius_km)
+                        continue;
+                    entry.distance_km = Math.round(dist * 10) / 10;
+                }
+                results.push(entry);
+            }
+        }
+        // Sort: by distance if lat/lon provided, otherwise by name
+        if (hasLatLon) {
+            results.sort((a, b) => (a.distance_km ?? 9999) - (b.distance_km ?? 9999));
+        }
+        else {
+            results.sort((a, b) => a.name.localeCompare(b.name));
+        }
+        const total_found = results.length;
+        if (total_found === 0) {
+            throw ctx.fail('no_results', 'No stations match the specified search criteria.', {
+                ...ctx.recoveryFor('no_results'),
+            });
+        }
+        const stations = results.slice(0, input.limit);
+        ctx.log.info('Station search complete', {
+            total_found,
+            returned: stations.length,
+            source: input.source,
+        });
+        return { stations, total_found };
+    },
+    format: (result) => {
+        const lines = [
+            `**${result.total_found} station(s) found** (showing ${result.stations.length})\n`,
+        ];
+        for (const s of result.stations) {
+            const dist = s.distance_km !== undefined ? ` · ${s.distance_km} km` : '';
+            const state = s.state ? ` · ${s.state}` : '';
+            lines.push(`### ${s.name} (${s.station_id})`, `**Source:** ${s.source.toUpperCase()} · **Type:** ${s.type}${dist}${state}`, `**Coordinates:** ${s.latitude}, ${s.longitude}`, `**Capabilities:** ${s.capabilities.join(', ')}`, '');
+        }
+        return [{ type: 'text', text: lines.join('\n') }];
+    },
+});
+//# sourceMappingURL=noaa-marine-find-stations.tool.js.map