@rnsk/toolkits 0.0.9 → 0.0.11

package/dist/toolkits/nasa/tools/power.d.ts

@@ -0,0 +1,52 @@
+export declare const nasaGetPowerClimatology: import("ai").Tool<{
+    parameters: string;
+    latitude: number;
+    longitude: number;
+    community: "RE" | "SB" | "AG";
+    format?: "JSON" | "CSV" | "ASCII" | "NETCDF" | "ICASA" | "GeoJSON" | undefined;
+    nasaApiKey?: string | undefined;
+}, any>;
+export declare const nasaGetPowerDaily: import("ai").Tool<{
+    parameters: string;
+    start: string;
+    end: string;
+    latitude: number;
+    longitude: number;
+    community: "RE" | "SB" | "AG";
+    format?: "JSON" | "GeoJSON" | undefined;
+    nasaApiKey?: string | undefined;
+}, any>;
+export declare const nasaGetPowerDailyRegional: import("ai").Tool<{
+    parameters: string;
+    start: string;
+    end: string;
+    community: "RE" | "SB" | "AG";
+    latitudeMax: number;
+    latitudeMin: number;
+    longitudeMax: number;
+    longitudeMin: number;
+    format?: "JSON" | "CSV" | "ASCII" | "NETCDF" | "ICASA" | undefined;
+    nasaApiKey?: string | undefined;
+}, any>;
+export declare const nasaGetPowerMonthly: import("ai").Tool<{
+    parameters: string;
+    start: string;
+    end: string;
+    latitude: number;
+    longitude: number;
+    community: "RE" | "SB" | "AG";
+    format?: "JSON" | "CSV" | "NETCDF" | "GEOTIFF" | undefined;
+    nasaApiKey?: string | undefined;
+}, any>;
+export declare const nasaGetPowerTemporalHourly: import("ai").Tool<{
+    parameters: string;
+    start: string;
+    end: string;
+    latitude: number;
+    longitude: number;
+    community: "RE" | "SB" | "AG";
+    format?: "JSON" | "CSV" | "ASCII" | "NETCDF" | "ICASA" | undefined;
+    nasaApiKey?: string | undefined;
+    timeStandard?: "UTC" | "LST" | undefined;
+}, any>;
+//# sourceMappingURL=power.d.ts.map

package/dist/toolkits/nasa/tools/power.js

@@ -0,0 +1,213 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { nasaGet, nasaGetText, toNasaError } from './client.js';
+export const nasaGetPowerClimatology = tool({
+    description: "Retrieves long-term climatology data for a specific location from NASA POWER (Prediction Of Worldwide Energy Resources). Returns average values over a climate period, including monthly and annual climate statistics for parameters like temperature, solar radiation, wind speed, and precipitation. Use this when you need long-term climate averages for renewable energy planning, sustainable building design, or agricultural applications.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        format: z.enum(["JSON", "CSV", "ASCII", "NETCDF", "ICASA", "GeoJSON"]).optional().describe("Output format types for NASA POWER API."),
+        latitude: z.number().min(-90).max(90).describe("Latitude coordinate in decimal degrees. Valid range: -90 to 90."),
+        community: z.enum(["RE", "SB", "AG"]).describe("User community designation. RE = Renewable Energy, SB = Sustainable Buildings, AG = Agroclimatology. Affects parameter availability and units."),
+        longitude: z.number().min(-180).max(180).describe("Longitude coordinate in decimal degrees. Valid range: -180 to 180."),
+        parameters: z.string().describe("Comma-separated list of POWER parameter codes (e.g., 'T2M,PRECTOTCORR,WS2M'). Maximum 20 parameters per request. Common parameters: T2M (Temperature at 2 Meters), PRECTOTCORR (Precipitation Corrected), WS2M (Wind Speed at 2 Meters), RH2M (Relative Humidity), ALLSKY_SFC_SW_DWN (Solar Radiation). Returns long-term climate averages for these parameters."),
+    }),
+    execute: async ({ nasaApiKey, parameters, community, longitude, latitude, format }) => {
+        try {
+            const query = {};
+            if (format !== undefined)
+                query["format"] = format;
+            if (latitude !== undefined)
+                query["latitude"] = latitude;
+            if (community !== undefined)
+                query["community"] = community;
+            if (longitude !== undefined)
+                query["longitude"] = longitude;
+            if (parameters !== undefined)
+                query["parameters"] = parameters;
+            if (format === undefined || format === 'JSON') {
+                const q2 = { ...query, format: 'JSON' };
+                return await nasaGet("https://power.larc.nasa.gov", `/api/temporal/climatology/point`, { query: q2 });
+            }
+            const q2 = { ...query };
+            return await nasaGetText("https://power.larc.nasa.gov", `/api/temporal/climatology/point`, { query: q2 });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get power climatology");
+        }
+    },
+});
+export const nasaGetPowerDaily = tool({
+    description: "Retrieves daily average solar and meteorological data from NASA POWER (Prediction Of Worldwide Energy Resources). Returns time-series data for parameters like temperature, solar radiation, wind speed, humidity, and precipitation from 1981 to near real-time. Use this when you need historical or recent climate data for a specific location to support renewable energy planning, building design, or agricultural applications.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        end: z.string().describe("End date in YYYYMMDD format (e.g., '20240107'). Must be on or after start date."),
+        start: z.string().describe("Start date in YYYYMMDD format (e.g., '20240101'). Valid range: 19810101 to near real-time."),
+        format: z.enum(["JSON", "GeoJSON"]).optional().describe("Output format types for NASA POWER API. Only JSON-based formats are supported."),
+        latitude: z.number().min(-90).max(90).describe("Latitude coordinate in decimal degrees. Valid range: -90 to 90."),
+        community: z.enum(["RE", "SB", "AG"]).describe("User community designation. RE = Renewable Energy, SB = Sustainable Buildings, AG = Agroclimatology. Affects parameter availability and units."),
+        longitude: z.number().min(-180).max(180).describe("Longitude coordinate in decimal degrees. Valid range: -180 to 180."),
+        parameters: z.string().describe("Comma-separated list of POWER parameter codes (e.g., 'T2M,PRECTOTCORR,WS2M'). Maximum 20 parameters per request. Common parameters: T2M (Temperature at 2 Meters), PRECTOTCORR (Precipitation Corrected), WS2M (Wind Speed at 2 Meters), RH2M (Relative Humidity), ALLSKY_SFC_SW_DWN (Solar Radiation)."),
+    }),
+    execute: async ({ nasaApiKey, parameters, community, longitude, latitude, start, end, format }) => {
+        try {
+            const query = {};
+            if (end !== undefined)
+                query["end"] = end;
+            if (start !== undefined)
+                query["start"] = start;
+            if (format !== undefined)
+                query["format"] = format;
+            if (latitude !== undefined)
+                query["latitude"] = latitude;
+            if (community !== undefined)
+                query["community"] = community;
+            if (longitude !== undefined)
+                query["longitude"] = longitude;
+            if (parameters !== undefined)
+                query["parameters"] = parameters;
+            if (format === undefined || format === 'JSON') {
+                const q2 = { ...query, format: 'JSON' };
+                return await nasaGet("https://power.larc.nasa.gov", `/api/temporal/daily/point`, { query: q2 });
+            }
+            const q2 = { ...query };
+            return await nasaGetText("https://power.larc.nasa.gov", `/api/temporal/daily/point`, { query: q2 });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get power daily");
+        }
+    },
+});
+export const nasaGetPowerDailyRegional = tool({
+    description: "Tool to retrieve daily average solar and meteorological data for a regional bounding box from NASA POWER (Prediction Of Worldwide Energy Resources). Use when you need historical or recent climate data for a geographic region (not just a single point). Returns time-series data on a 0.5 x 0.5 degree grid for parameters like temperature, solar radiation, wind speed, humidity, and precipitation from 1981 to near real-time. Regional requests require at least a 2-degree range in both latitude and longitude, and are limited to ONE parameter per request.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        end: z.string().describe("End date in YYYYMMDD format (e.g., '20230107'). Must be on or after start date."),
+        start: z.string().describe("Start date in YYYYMMDD format (e.g., '20230101'). Valid range: 19810101 to near real-time."),
+        format: z.enum(["JSON", "CSV", "ASCII", "NETCDF", "ICASA"]).optional().describe("Output format types for NASA POWER API."),
+        community: z.enum(["RE", "SB", "AG"]).describe("User community designation. RE = Renewable Energy, SB = Sustainable Buildings, AG = Agroclimatology. Affects parameter availability and units."),
+        parameters: z.string().describe("Single POWER parameter code to retrieve (e.g., 'T2M', 'PRECTOTCORR', 'WS2M'). Regional requests are limited to ONE parameter per submission. Common parameters: T2M (Temperature at 2 Meters), PRECTOTCORR (Precipitation Corrected), WS2M (Wind Speed at 2 Meters), RH2M (Relative Humidity), ALLSKY_SFC_SW_DWN (Solar Radiation)."),
+        latitudeMax: z.number().min(-90).max(90).describe("Maximum latitude of the bounding box in decimal degrees. Valid range: -90 to 90. Must be at least 2 degrees greater than latitude_min."),
+        latitudeMin: z.number().min(-90).max(90).describe("Minimum latitude of the bounding box in decimal degrees. Valid range: -90 to 90. Must be at least 2 degrees less than latitude_max."),
+        longitudeMax: z.number().min(-180).max(180).describe("Maximum longitude of the bounding box in decimal degrees. Valid range: -180 to 180. Must be at least 2 degrees greater than longitude_min."),
+        longitudeMin: z.number().min(-180).max(180).describe("Minimum longitude of the bounding box in decimal degrees. Valid range: -180 to 180. Must be at least 2 degrees less than longitude_max."),
+    }),
+    execute: async ({ nasaApiKey, latitudeMin, latitudeMax, longitudeMin, longitudeMax, parameters, community, start, end, format }) => {
+        try {
+            const query = {};
+            if (end !== undefined)
+                query["end"] = end;
+            if (start !== undefined)
+                query["start"] = start;
+            if (format !== undefined)
+                query["format"] = format;
+            if (community !== undefined)
+                query["community"] = community;
+            if (parameters !== undefined)
+                query["parameters"] = parameters;
+            if (latitudeMax !== undefined)
+                query["latitude-max"] = latitudeMax;
+            if (latitudeMin !== undefined)
+                query["latitude-min"] = latitudeMin;
+            if (longitudeMax !== undefined)
+                query["longitude-max"] = longitudeMax;
+            if (longitudeMin !== undefined)
+                query["longitude-min"] = longitudeMin;
+            if (format === undefined || format === 'JSON') {
+                const q2 = { ...query, format: 'JSON' };
+                return await nasaGet("https://power.larc.nasa.gov", `/api/temporal/daily/regional`, { query: q2 });
+            }
+            const q2 = { ...query };
+            return await nasaGetText("https://power.larc.nasa.gov", `/api/temporal/daily/regional`, { query: q2 });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get power daily regional");
+        }
+    },
+});
+export const nasaGetPowerMonthly = tool({
+    description: "Retrieves monthly average solar and meteorological data for a specific location from NASA POWER (Prediction Of Worldwide Energy Resources). Returns time series data with monthly averages organized by year-month for parameters like temperature, precipitation, solar irradiance, and humidity. Use this when you need long-term climate analysis, renewable energy assessments, or agricultural planning data for a specific geographic location. Data availability generally ranges from 1981 to near real-time depending on the parameter.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        end: z.string().describe("End year for the data range in YYYY format (e.g., '2021'). Must be greater than or equal to start year."),
+        start: z.string().describe("Start year for the data range in YYYY format (e.g., '2020'). Data availability varies by parameter but generally starts from 1981."),
+        format: z.enum(["JSON", "CSV", "NETCDF", "GEOTIFF"]).optional().describe("Output format types."),
+        latitude: z.number().min(-90).max(90).describe("Latitude of the location in decimal degrees. Must be between -90 and 90."),
+        community: z.enum(["RE", "SB", "AG"]).describe("User community determining the parameter set and data processing. RE (Renewable Energy) for solar energy applications, SB (Sustainable Buildings) for building design, AG (Agroclimatology) for agricultural applications."),
+        longitude: z.number().min(-180).max(180).describe("Longitude of the location in decimal degrees. Must be between -180 and 180."),
+        parameters: z.string().describe("Comma-separated list of POWER parameter names (e.g., 'T2M,PRECTOTCORR,RH2M'). Common parameters include T2M (Temperature at 2 Meters), PRECTOTCORR (Precipitation Corrected), RH2M (Relative Humidity at 2 Meters), ALLSKY_SFC_SW_DWN (All Sky Surface Shortwave Downward Irradiance). Maximum 20 parameters per request."),
+    }),
+    execute: async ({ nasaApiKey, parameters, community, longitude, latitude, start, end, format }) => {
+        try {
+            const query = {};
+            if (end !== undefined)
+                query["end"] = end;
+            if (start !== undefined)
+                query["start"] = start;
+            if (format !== undefined)
+                query["format"] = format;
+            if (latitude !== undefined)
+                query["latitude"] = latitude;
+            if (community !== undefined)
+                query["community"] = community;
+            if (longitude !== undefined)
+                query["longitude"] = longitude;
+            if (parameters !== undefined)
+                query["parameters"] = parameters;
+            if (format === undefined || format === 'JSON') {
+                const q2 = { ...query, format: 'JSON' };
+                return await nasaGet("https://power.larc.nasa.gov", `/api/temporal/monthly/point`, { query: q2 });
+            }
+            const q2 = { ...query };
+            return await nasaGetText("https://power.larc.nasa.gov", `/api/temporal/monthly/point`, { query: q2 });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get power monthly");
+        }
+    },
+});
+export const nasaGetPowerTemporalHourly = tool({
+    description: "Retrieves hourly climate and meteorological data from NASA POWER (Prediction of Worldwide Energy Resources) API for a specific location and date range. Returns high-resolution temporal data including temperature, humidity, precipitation, and other parameters. Use this when you need detailed hourly weather/climate data for renewable energy, sustainable buildings, or agroclimatology applications. Data available from 2001 to near real-time.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        end: z.string().describe("End date for hourly data retrieval in YYYYMMDD format (e.g., '20230131'). Must be on or after start date. Returns hourly data for all hours between start and end dates (inclusive)."),
+        start: z.string().describe("Start date for hourly data retrieval in YYYYMMDD format (e.g., '20230101'). Available from 2001-01-01 (20010101) to near real-time. The API returns hourly data for all hours within the date range."),
+        format: z.enum(["JSON", "CSV", "ASCII", "ICASA", "NETCDF"]).optional().describe("Output format options for POWER API."),
+        latitude: z.number().min(-90).max(90).describe("Latitude coordinate of the location in decimal degrees. Must be between -90 and 90. Negative values represent south, positive values represent north."),
+        community: z.enum(["RE", "SB", "AG"]).describe("User community for the data request. Options: 'RE' (Renewable Energy), 'SB' (Sustainable Buildings), 'AG' (Agroclimatology). Each community may have different available parameters."),
+        longitude: z.number().min(-180).max(180).describe("Longitude coordinate of the location in decimal degrees. Must be between -180 and 180. Negative values represent west, positive values represent east."),
+        parameters: z.string().describe("Comma-separated list of POWER parameters to retrieve (e.g., 'T2M', 'RH2M', 'PRECTOTCORR', 'T2M,RH2M'). T2M = Temperature at 2 Meters, RH2M = Relative Humidity at 2 Meters, PRECTOTCORR = Precipitation Corrected. Consult POWER documentation for full parameter list."),
+        timeStandard: z.enum(["UTC", "LST"]).optional().describe("Time standard for hourly data."),
+    }),
+    execute: async ({ nasaApiKey, parameters, community, longitude, latitude, start, end, format, timeStandard }) => {
+        try {
+            const query = {};
+            if (end !== undefined)
+                query["end"] = end;
+            if (start !== undefined)
+                query["start"] = start;
+            if (format !== undefined)
+                query["format"] = format;
+            if (latitude !== undefined)
+                query["latitude"] = latitude;
+            if (community !== undefined)
+                query["community"] = community;
+            if (longitude !== undefined)
+                query["longitude"] = longitude;
+            if (parameters !== undefined)
+                query["parameters"] = parameters;
+            if (timeStandard !== undefined)
+                query["time_standard"] = timeStandard;
+            if (format === undefined || format === 'JSON') {
+                const q2 = { ...query, format: 'JSON' };
+                return await nasaGet("https://power.larc.nasa.gov", `/api/temporal/hourly/point`, { query: q2 });
+            }
+            const q2 = { ...query };
+            return await nasaGetText("https://power.larc.nasa.gov", `/api/temporal/hourly/point`, { query: q2 });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get power temporal hourly");
+        }
+    },
+});
+//# sourceMappingURL=power.js.map

package/dist/toolkits/nasa/tools/ssc.d.ts

@@ -0,0 +1,44 @@
+export declare const nasaCreateGraphRequest: import("ai").Tool<{
+    satellites: Record<string, any>[];
+    graphOptions: {
+        coordinateSystem: "GEO" | "GM" | "GSE" | "GSM" | "SM" | "GEI_TOD" | "GEI_J2000";
+    };
+    timeInterval: {
+        start: string;
+        end: string;
+    };
+    description?: string | undefined;
+    nasaApiKey?: string | undefined;
+}, any>;
+export declare const nasaGetSatelliteLocations: import("ai").Tool<{
+    description: string;
+    satellites: Record<string, any>[];
+    timeInterval: {
+        start: string;
+        end: string;
+    };
+    nasaApiKey?: string | undefined;
+    bFieldModel?: {
+        traceStopAltitude?: number | undefined;
+        externalBFieldModel?: {
+            keyParameterValues?: string | undefined;
+        } | undefined;
+        internalBFieldModel?: string | undefined;
+    } | undefined;
+    outputOptions?: {
+        coordinateOptions: Record<string, any>[];
+    } | undefined;
+}, any>;
+export declare const nasaListGroundStations: import("ai").Tool<{
+    nasaApiKey?: string | undefined;
+}, any>;
+export declare const nasaListObservatories: import("ai").Tool<{
+    nasaApiKey?: string | undefined;
+}, any>;
+export declare const nasaListLocationsGseGeo: import("ai").Tool<{
+    satellites: string;
+    timeRange: string;
+    nasaApiKey?: string | undefined;
+    resolutionFactor?: number | undefined;
+}, any>;
+//# sourceMappingURL=ssc.d.ts.map

package/dist/toolkits/nasa/tools/ssc.js

@@ -0,0 +1,92 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { toNasaError, sscGet, sscGraph, sscLocations, enc } from './client.js';
+export const nasaCreateGraphRequest = tool({
+    description: "Tool to create orbital and position graphs for NASA satellites using the Satellite Situation Center (SSC) web service. Use when you need to visualize satellite trajectories, orbits, or positions over a specific time period in various coordinate systems. The service generates graph files accessible via URLs in the response.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        satellites: z.array(z.record(z.any())).min(1).describe("List of satellites to include in the graph. Must specify at least one satellite. Each satellite needs an ID and optional resolution factor."),
+        description: z.string().optional().describe("Optional description of the graph request for reference purposes."),
+        graphOptions: z.object({ coordinateSystem: z.enum(["GEO", "GM", "GSE", "GSM", "SM", "GEI_TOD", "GEI_J2000"]).describe("Coordinate system for the orbit graph. Options: GEO (Geographic), GM (Geomagnetic), GSE (Geocentric Solar Ecliptic), GSM (Geocentric Solar Magnetospheric), SM (Solar Magnetic), GEI_TOD (Geocentric Equatorial Inertial True-Of-Date), GEI_J2000 (Geocentric Equatorial Inertial J2000).") }).describe("Visualization options for the orbit graph, including the coordinate system to use for displaying satellite positions."),
+        timeInterval: z.object({ end: z.string().describe("End time in ISO 8601 format (e.g., '2026-02-14T01:00:00.000Z'). This is the end of the time range for the graph."), start: z.string().describe("Start time in ISO 8601 format (e.g., '2026-02-14T00:00:00.000Z'). This is the beginning of the time range for the graph.") }).describe("Time range for the graph data. Specifies the start and end times for which satellite position data should be visualized."),
+    }),
+    execute: async ({ nasaApiKey, timeInterval, satellites, graphOptions, description }) => {
+        try {
+            return await sscGraph({ time_interval: timeInterval, satellites, graph_options: graphOptions, description });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to create graph request");
+        }
+    },
+});
+export const nasaGetSatelliteLocations = tool({
+    description: "Retrieves satellite location data from NASA's Satellite Situation Center (SSC). Returns position coordinates for specified satellites over a time interval using configurable coordinate systems and magnetic field models. Use this when you need to track satellite positions, analyze orbital trajectories, or retrieve historical satellite location data.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        satellites: z.array(z.record(z.any())).min(1).describe("List of satellites to retrieve location data for. Each satellite requires an ID and resolution factor."),
+        description: z.string().describe("Brief description of the data request for tracking purposes."),
+        bFieldModel: z.object({ traceStopAltitude: z.number().int().optional().describe("Altitude in km at which to stop field line tracing. Default is 100 km."), externalBFieldModel: z.object({ keyParameterValues: z.string().optional().describe("Key parameter values for the external B-field model. Format: 'KP_X_X_X' where X is a digit 0-9. Default is 'KP_3_3_3'.") }).optional().describe("External magnetic field model parameters (Tsyganenko 89C model)."), internalBFieldModel: z.string().optional().describe("Internal magnetic field model to use. Default is 'IGRF' (International Geomagnetic Reference Field).") }).optional().describe("Magnetic field model specification."),
+        timeInterval: z.object({ end: z.string().describe("End time in ISO 8601 format (e.g., '2024-01-01T01:00:00.000+0000'). Specifies the end of the time range for satellite location data."), start: z.string().describe("Start time in ISO 8601 format (e.g., '2024-01-01T00:00:00.000+0000'). Specifies the beginning of the time range for satellite location data.") }).describe("Time range for which to retrieve satellite location data."),
+        outputOptions: z.object({ coordinateOptions: z.array(z.record(z.any())).min(1).describe("List of coordinate options specifying which coordinate systems and components to include in the response. Typically includes X, Y, and Z components for a coordinate system.") }).optional().describe("Output options for satellite location data."),
+    }),
+    execute: async ({ nasaApiKey, description, timeInterval, satellites, bFieldModel, outputOptions }) => {
+        try {
+            return await sscLocations({ time_interval: timeInterval, satellites, b_field_model: bFieldModel, output_options: outputOptions, description });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get satellite locations");
+        }
+    },
+});
+export const nasaListGroundStations = tool({
+    description: "Retrieves the complete list of ground stations available from NASA's Satellite Situation Center (SSC). Returns metadata for each ground station including unique identifier, name, and geographic coordinates (latitude/longitude). Use this tool when you need information about SSC ground station locations for satellite tracking or geophysical research.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+    }),
+    execute: async ({ nasaApiKey }) => {
+        try {
+            const query = {};
+            return await sscGet(`/groundStations`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to list ground stations");
+        }
+    },
+});
+export const nasaListObservatories = tool({
+    description: "Tool to retrieve descriptions of all observatories available from NASA's Satellite Situation Center (SSC). Use when you need to discover available satellites, their identifiers, data availability periods, and trajectory resolutions. Returns comprehensive metadata for each observatory including time ranges and resource identifiers.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+    }),
+    execute: async ({ nasaApiKey }) => {
+        try {
+            const query = {};
+            return await sscGet(`/observatories`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to list observatories");
+        }
+    },
+});
+export const nasaListLocationsGseGeo = tool({
+    description: "Retrieves satellite/observatory location data in GSE and GEO coordinate systems from NASA's SSC (Satellite Situation Center). Returns time-series coordinate data including X, Y, Z positions, latitude, longitude, and local time for specified satellites over a time range. Use this when you need spacecraft position data for trajectory analysis or orbital tracking. Minimum time interval is 24 hours.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        satellites: z.string().describe("Comma-separated list of satellite/observatory identifiers (e.g., 'ace', 'iss', 'ace,iss'). Valid values must be from the SSC observatories list."),
+        timeRange: z.string().describe("Time interval as two comma-separated ISO 8601 basic format datetime values (e.g., '20260101T000000Z,20260102T000000Z'). The interval must be at least 24 hours."),
+        resolutionFactor: z.number().int().min(1).optional().describe("Controls data density by including 1 out of every resolutionFactor values. Higher values reduce the number of data points returned."),
+    }),
+    execute: async ({ nasaApiKey, satellites, timeRange, resolutionFactor }) => {
+        try {
+            const query = {};
+            if (resolutionFactor !== undefined)
+                query["resolution_factor"] = resolutionFactor;
+            return await sscGet(`/locations/${enc(satellites)}/${enc(timeRange)}/GSE,GEO`, { query });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to list locations gse geo");
+        }
+    },
+});
+//# sourceMappingURL=ssc.js.map

package/dist/toolkits/nasa/tools/tolnet.d.ts

@@ -0,0 +1,84 @@
+export declare const nasaGetDataByFileName: import("ai").Tool<{
+    fileName: string;
+    nasaApiKey?: string | undefined;
+    matchType?: "exact_match" | "begins_with" | "ends_with" | undefined;
+}, any>;
+export declare const nasaGetTolnetDataJson: import("ai").Tool<{
+    id: number;
+    nasaApiKey?: string | undefined;
+}, any>;
+export declare const nasaGetTolnetDataJsonForGraph: import("ai").Tool<{
+    id: number;
+    nasaApiKey?: string | undefined;
+}, any>;
+export declare const nasaGetDocument: import("ai").Tool<{
+    id: number;
+    nasaApiKey?: string | undefined;
+}, any>;
+export declare const nasaGetDocumentDownload: import("ai").Tool<{
+    id: number;
+    nasaApiKey?: string | undefined;
+}, {
+    error: string;
+    details: unknown;
+    statusCode: number;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    statusCode?: undefined;
+} | {
+    name: string;
+    mimetype: string | null;
+    sizeBytes: number | null;
+    url: string;
+    note: string;
+}>;
+export declare const nasaGetDocuments: import("ai").Tool<{
+    type?: string | undefined;
+    q?: string | undefined;
+    page?: number | undefined;
+    order?: "author" | "public" | "display_date" | "document_name" | "document_type_name" | undefined;
+    nasaApiKey?: string | undefined;
+    orderDirection?: "asc" | "desc" | undefined;
+}, any>;
+export declare const nasaGetTolnetData: import("ai").Tool<{
+    page?: number | undefined;
+    order?: "data_date" | "upload_date" | "instrument_group_name" | "product_type_name" | "processing_type_name" | "file_type_name" | "file_name" | undefined;
+    latitude?: number | undefined;
+    longitude?: number | undefined;
+    radius?: number | undefined;
+    nasaApiKey?: string | undefined;
+    maxDate?: string | undefined;
+    minDate?: string | undefined;
+    productType?: string | undefined;
+    orderDirection?: "asc" | "desc" | undefined;
+    fileType?: string | undefined;
+    maxLatitude?: number | undefined;
+    minLatitude?: number | undefined;
+    maxLongitude?: number | undefined;
+    minLongitude?: number | undefined;
+    nearRealTime?: string | undefined;
+    maxUploadDate?: string | undefined;
+    minUploadDate?: string | undefined;
+    processingType?: string | undefined;
+    instrumentGroup?: string | undefined;
+}, any>;
+export declare const nasaGetTolnetDataCalendar: import("ai").Tool<{
+    fileType: string;
+    instrumentGroup: string;
+    nasaApiKey?: string | undefined;
+    productType?: string | undefined;
+    processingType?: string | undefined;
+}, any>;
+export declare const nasaGetFileTypes: import("ai").Tool<{
+    nasaApiKey?: string | undefined;
+}, any>;
+export declare const nasaGetInstrumentGroups: import("ai").Tool<{
+    nasaApiKey?: string | undefined;
+}, any>;
+export declare const nasaGetProductTypes: import("ai").Tool<{
+    nasaApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=tolnet.d.ts.map