@rnsk/toolkits 0.0.10 → 0.0.11

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

@@ -0,0 +1,279 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { nasaGet, toNasaError, enc, convertEonet } from './client.js';
+export const nasaGetEonetCategories = tool({
+    description: "Tool to retrieve a list of all event categories from EONET. Use when you need current category IDs, titles, descriptions, and info links. Note: category IDs are EONET-specific and do not map to CMR (Common Metadata Repository) IDs; use them only for EONET-internal filtering, not cross-system lookups.",
+    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 {
+            return await nasaGet("https://eonet.gsfc.nasa.gov/api/v3", `/categories`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get eonet categories");
+        }
+    },
+});
+export const nasaGetEonetCategoryEvents = tool({
+    description: "Tool to retrieve natural events filtered by a specific category from NASA's EONET. Use when you need events for a specific category like wildfires, volcanoes, or severe storms.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        end: z.string().optional().describe("Ending date for event filtering in YYYY-MM-DD format. Use with 'start' parameter to define a date range."),
+        days: z.number().int().positive().optional().describe("Limit events to those occurring within the last N days (including today)."),
+        limit: z.number().int().positive().optional().describe("Limit the number of events returned. Must be a positive integer."),
+        start: z.string().optional().describe("Starting date for event filtering in YYYY-MM-DD format. Use with 'end' parameter to define a date range."),
+        source: z.string().optional().describe("Filter events by source ID (e.g., 'IRWIN', 'JTWC'). Multiple sources can be comma-separated for boolean OR filtering."),
+        status: z.enum(["open", "closed"]).optional().describe("Event status filter options for EONET events."),
+        categoryId: z.string().describe("Filter events by category ID (e.g., 'wildfires', 'volcanoes', 'severeStorms'). This is required to retrieve events for a specific category."),
+    }),
+    execute: async ({ nasaApiKey, categoryId, end, days, limit, start, source, status }) => {
+        try {
+            const query = {};
+            if (status !== undefined)
+                query["status"] = status;
+            if (limit !== undefined)
+                query["limit"] = limit;
+            if (days !== undefined)
+                query["days"] = days;
+            if (start !== undefined)
+                query["start"] = start;
+            if (end !== undefined)
+                query["end"] = end;
+            if (source !== undefined)
+                query["source"] = source;
+            return await nasaGet("https://eonet.gsfc.nasa.gov/api/v3", `/categories/${enc(categoryId)}`, { query });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get eonet category events");
+        }
+    },
+});
+export const nasaGetEonetEvent = tool({
+    description: "Tool to retrieve a specific natural event by its unique ID from NASA's Earth Observatory Natural Event Tracker (EONET). Use when you need detailed information about a particular wildfire, storm, flood, volcano, earthquake, or other natural phenomenon.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        eventId: z.string().describe("Unique identifier of the EONET event (e.g., 'EONET_17841')"),
+    }),
+    execute: async ({ nasaApiKey, eventId }) => {
+        try {
+            return await nasaGet("https://eonet.gsfc.nasa.gov/api/v3", `/events/${enc(eventId)}`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get eonet event");
+        }
+    },
+});
+export const nasaGetEonetEvents = tool({
+    description: "Tool to retrieve natural events from NASA's Earth Observatory Natural Event Tracker (EONET). Use when you need structured JSON data about wildfires, storms, floods, volcanoes, earthquakes, and other natural phenomena. Supports filtering by source, category, status, date range, magnitude, and geographic bounding box.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        end: z.string().optional().describe("Ending date for events in YYYY-MM-DD format. Only events on or before this date will be returned."),
+        bbox: z.string().optional().describe("Bounding box filter in format 'lon1,lat1,lon2,lat2' where (lon1,lat1) is upper-left corner and (lon2,lat2) is lower-right corner. Returns events with datapoints within this box."),
+        days: z.number().int().positive().optional().describe("Filter events from the last N days (including today). For example, days=7 returns events from the past week."),
+        limit: z.number().int().positive().optional().describe("Limits the number of events returned. Must be a positive integer."),
+        magID: z.enum(["mag_kts", "mms", "sq_NM"]).optional().describe("Magnitude identifier types for filtering events."),
+        start: z.string().optional().describe("Starting date for events in YYYY-MM-DD format. Only events on or after this date will be returned."),
+        magMax: z.number().optional().describe("Maximum magnitude value for filtering events. Requires magID to be specified."),
+        magMin: z.number().optional().describe("Minimum magnitude value for filtering events. Requires magID to be specified."),
+        source: z.string().optional().describe("Filter events by source ID. Multiple sources can be comma-separated (e.g., 'IRWIN,JTWC'). Operates as boolean OR."),
+        status: z.enum(["open", "closed", "all"]).optional().describe("Status filter for EONET events."),
+        category: z.string().optional().describe("Filter events by category ID. Multiple categories can be comma-separated (e.g., 'wildfires,floods'). Operates as boolean OR."),
+    }),
+    execute: async ({ nasaApiKey, end, bbox, days, limit, magID, start, magMax, magMin, source, status, category }) => {
+        try {
+            const query = {};
+            if (start !== undefined)
+                query["start"] = start;
+            if (end !== undefined)
+                query["end"] = end;
+            if (bbox !== undefined)
+                query["bbox"] = bbox;
+            if (days !== undefined)
+                query["days"] = days;
+            if (limit !== undefined)
+                query["limit"] = limit;
+            if (magID !== undefined)
+                query["magID"] = magID;
+            if (magMin !== undefined)
+                query["magMin"] = magMin;
+            if (magMax !== undefined)
+                query["magMax"] = magMax;
+            if (source !== undefined)
+                query["source"] = source;
+            if (status !== undefined)
+                query["status"] = status;
+            if (category !== undefined)
+                query["category"] = category;
+            return await nasaGet("https://eonet.gsfc.nasa.gov/api/v3", `/events`, { query });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get eonet events");
+        }
+    },
+});
+export const nasaGetEonetEventsAtom = tool({
+    description: "Tool to retrieve a list of natural events in ATOM format. Use when you need a machine-readable XML feed of recent natural events from EONET.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        end: z.string().optional().describe("End date (inclusive) for events, in YYYY-MM-DD format."),
+        bbox: z.string().optional().describe("Bounding box in 'minLon,minLat,maxLon,maxLat' format to restrict events geographically."),
+        days: z.number().int().min(0).optional().describe("Return events from the past N days (including today). Must be ≥ 0."),
+        limit: z.number().int().min(1).optional().describe("Maximum number of events to return. Must be ≥ 1."),
+        start: z.string().optional().describe("Start date (inclusive) for events, in YYYY-MM-DD format."),
+        magMax: z.number().optional().describe("Maximum magnitude value (inclusive)."),
+        magMin: z.number().optional().describe("Minimum magnitude value (inclusive)."),
+        magId: z.string().optional().describe("Magnitude ID to filter by (see /magnitudes endpoint)."),
+        source: z.string().optional().describe("Comma-separated list of Source IDs to filter events by. Operates as a boolean OR when multiple provided."),
+        status: z.enum(["open", "closed", "all"]).optional().describe("Filter by event status. 'open' (default) returns only active events; 'closed' returns only ended events; 'all' returns both."),
+        category: z.string().optional().describe("Comma-separated list of Category IDs to filter events by. Operates as a boolean OR when multiple provided."),
+    }),
+    execute: async ({ nasaApiKey, end, bbox, days, limit, start, magMax, magMin, magId, source, status, category }) => {
+        try {
+            const query = {};
+            if (end !== undefined)
+                query["end"] = end;
+            if (bbox !== undefined)
+                query["bbox"] = bbox;
+            if (days !== undefined)
+                query["days"] = days;
+            if (limit !== undefined)
+                query["limit"] = limit;
+            if (start !== undefined)
+                query["start"] = start;
+            if (magMax !== undefined)
+                query["magMax"] = magMax;
+            if (magMin !== undefined)
+                query["magMin"] = magMin;
+            if (magId !== undefined)
+                query["mag_id"] = magId;
+            if (source !== undefined)
+                query["source"] = source;
+            if (status !== undefined)
+                query["status"] = status;
+            if (category !== undefined)
+                query["category"] = category;
+            const data = await nasaGet("https://eonet.gsfc.nasa.gov/api/v3", `/events`, { query });
+            return convertEonet(data, "atom");
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get eonet events atom");
+        }
+    },
+});
+export const nasaGetEonetEventsGeojson = tool({
+    description: "Tool to retrieve natural events from NASA's Earth Observatory Natural Event Tracker (EONET) in GeoJSON format. Use when you need geographic event data in GeoJSON format for mapping applications or GIS integration. Supports filtering by source, category, status, date range, and geographic bounding box.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        end: z.string().optional().describe("Ending date for events in YYYY-MM-DD format. Only events on or before this date will be returned."),
+        bbox: z.string().optional().describe("Bounding box filter in format 'lon1,lat1,lon2,lat2' where (lon1,lat1) is upper-left corner and (lon2,lat2) is lower-right corner. Returns events with datapoints within this box."),
+        days: z.number().int().positive().optional().describe("Filter events from the last N days (including today). For example, days=7 returns events from the past week."),
+        limit: z.number().int().positive().optional().describe("Limits the number of events returned. Must be a positive integer."),
+        start: z.string().optional().describe("Starting date for events in YYYY-MM-DD format. Only events on or after this date will be returned."),
+        source: z.string().optional().describe("Filter events by source ID. Multiple sources can be comma-separated (e.g., 'IRWIN,JTWC'). Operates as boolean OR."),
+        status: z.enum(["open", "closed", "all"]).optional().describe("Status filter for EONET events."),
+        category: z.string().optional().describe("Filter events by category ID. Multiple categories can be comma-separated (e.g., 'wildfires,floods'). Operates as boolean OR."),
+    }),
+    execute: async ({ nasaApiKey, end, bbox, days, limit, start, source, status, category }) => {
+        try {
+            const query = {};
+            if (end !== undefined)
+                query["end"] = end;
+            if (bbox !== undefined)
+                query["bbox"] = bbox;
+            if (days !== undefined)
+                query["days"] = days;
+            if (limit !== undefined)
+                query["limit"] = limit;
+            if (start !== undefined)
+                query["start"] = start;
+            if (source !== undefined)
+                query["source"] = source;
+            if (status !== undefined)
+                query["status"] = status;
+            if (category !== undefined)
+                query["category"] = category;
+            const data = await nasaGet("https://eonet.gsfc.nasa.gov/api/v3", `/events`, { query });
+            return convertEonet(data, "geojson");
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get eonet events geojson");
+        }
+    },
+});
+export const nasaGetEonetEventsRss = tool({
+    description: "Retrieve natural events from NASA's Earth Observatory Natural Event Tracker (EONET) in RSS/GeoRSS XML format. This tool provides a standardized RSS 2.0 feed with GeoRSS extensions, ideal for RSS readers, mapping applications, or systems that need spatial event data in XML format. The feed includes wildfires, storms, floods, volcanoes, icebergs, and other natural phenomena with geographical coordinates, magnitudes, and source references. Use this when you need RSS/XML format specifically. For programmatic access with structured data, consider using the JSON events endpoint instead.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        days: z.number().int().positive().optional().describe("Filter events that occurred within the last N days. For example, days=10 returns events from the past 10 days only."),
+        limit: z.number().int().positive().optional().describe("Limit the number of events returned in the RSS feed. Must be a positive integer. Useful for getting just the most recent events."),
+        source: z.string().optional().describe("Filter events by source ID (e.g., 'IRWIN', 'JTWC', 'BYU_ICE'). Only events from the specified source will be included in the RSS feed."),
+        status: z.string().optional().describe("Filter events by status: 'open' for ongoing events or 'closed' for completed events. Defaults to all statuses if not specified."),
+    }),
+    execute: async ({ nasaApiKey, days, limit, source, status }) => {
+        try {
+            const query = {};
+            if (days !== undefined)
+                query["days"] = days;
+            if (limit !== undefined)
+                query["limit"] = limit;
+            if (source !== undefined)
+                query["source"] = source;
+            if (status !== undefined)
+                query["status"] = status;
+            const data = await nasaGet("https://eonet.gsfc.nasa.gov/api/v3", `/events`, { query });
+            return convertEonet(data, "rss");
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get eonet events rss");
+        }
+    },
+});
+export const nasaGetEonetLayers = tool({
+    description: "Retrieves NASA EONET imagery layers for visualizing natural events. Returns web map service (WMS/WMTS) layer definitions that can be used to display satellite imagery related to events like wildfires, volcanoes, severe storms, etc. Each layer includes service URLs and parameters needed to fetch imagery tiles. Use the optional category parameter to get layers specific to an event type (recommended to avoid empty results).",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        category: z.string().optional().describe("Category ID to filter layers by specific event type. Valid values include: 'wildfires', 'volcanoes', 'severeStorms', 'floods', 'landslides', 'earthquakes', 'drought', 'dustHaze', 'snow', 'seaLakeIce', 'tempExtremes', 'waterColor', 'manmade'. If omitted, returns all layers (note: may return empty list)."),
+    }),
+    execute: async ({ nasaApiKey, category }) => {
+        try {
+            const query = {};
+            if (category !== undefined)
+                query["category"] = category;
+            return await nasaGet("https://eonet.gsfc.nasa.gov/api/v3", `/layers`, { query });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get eonet layers");
+        }
+    },
+});
+export const nasaGetEonetMagnitudes = tool({
+    description: "Tool to retrieve a list of available event magnitudes and their descriptions. Use after determining you need valid magnitude filters before querying events data.",
+    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 {
+            return await nasaGet("https://eonet.gsfc.nasa.gov/api/v3", `/magnitudes`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get eonet magnitudes");
+        }
+    },
+});
+export const nasaGetEonetSources = tool({
+    description: "Retrieves the complete list of event data sources available in NASA's EONET (Earth Observatory Natural Event Tracker) system. Each source provides natural event data such as wildfires, volcanoes, hurricanes, floods, and earthquakes. Use this tool to: - Discover which organizations provide event data to EONET - Get source IDs for filtering events by specific data providers - Access homepage URLs and filtered event endpoints for each source No parameters required - returns all available sources.",
+    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 {
+            return await nasaGet("https://eonet.gsfc.nasa.gov/api/v3", `/sources`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get eonet sources");
+        }
+    },
+});
+//# sourceMappingURL=eonet.js.map

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

@@ -0,0 +1,25 @@
+export declare const nasaGetIcesat2Tracks: import("ai").Tool<{
+    date?: string | undefined;
+    nasaApiKey?: string | undefined;
+    maxx?: number | undefined;
+    maxy?: number | undefined;
+    minx?: number | undefined;
+    miny?: number | undefined;
+    outputFormat?: "json" | "csv" | undefined;
+}, any>;
+export declare const nasaGetLevel3Data: import("ai").Tool<{
+    product: "atl06" | "atl07" | "atl08" | "atl10" | "atl12" | "atl13";
+    maxx: number;
+    maxy: number;
+    minx: number;
+    miny: number;
+    trackId: number;
+    date?: string | undefined;
+    client?: string | undefined;
+    startDate?: string | undefined;
+    endDate?: string | undefined;
+    nasaApiKey?: string | undefined;
+    outputFormat?: "json" | "csv" | "zip" | undefined;
+    beamNames?: string[] | undefined;
+}, any>;
+//# sourceMappingURL=icesat2.d.ts.map

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

@@ -0,0 +1,97 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { nasaGetText, nasaGet, toNasaError, enc } from './client.js';
+export const nasaGetIcesat2Tracks = tool({
+    description: "Retrieves a list of ICESat-2 satellite tracks (Reference Ground Tracks - RGTs) within a specified geographic bounding box. Use this when you need to identify which ICESat-2 tracks pass through a particular region of interest. The returned track identifiers can be used to query detailed altimetry data for those specific tracks. Supports optional date filtering to find tracks from a specific collection date.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        date: z.string().optional().describe("Data collection date filter in yyyy-MM-dd format (e.g., '2019-12-25'). If specified, only tracks from this date will be returned."),
+        maxx: z.number().optional().describe("Maximum x coordinate (longitude) of the bounding box in decimal degrees. Eastern boundary of the area of interest."),
+        maxy: z.number().optional().describe("Maximum y coordinate (latitude) of the bounding box in decimal degrees. Northern boundary of the area of interest."),
+        minx: z.number().optional().describe("Minimum x coordinate (longitude) of the bounding box in decimal degrees. Western boundary of the area of interest."),
+        miny: z.number().optional().describe("Minimum y coordinate (latitude) of the bounding box in decimal degrees. Southern boundary of the area of interest."),
+        outputFormat: z.enum(["csv", "json"]).optional().describe("Output format of the result. 'json' returns structured JSON data, 'csv' returns comma-separated values."),
+    }),
+    execute: async ({ nasaApiKey, date, maxx, maxy, minx, miny, outputFormat }) => {
+        try {
+            const query = {};
+            if (minx !== undefined)
+                query["minx"] = minx;
+            if (miny !== undefined)
+                query["miny"] = miny;
+            if (maxx !== undefined)
+                query["maxx"] = maxx;
+            if (maxy !== undefined)
+                query["maxy"] = maxy;
+            if (date !== undefined)
+                query["date"] = date;
+            if (outputFormat !== undefined)
+                query["outputFormat"] = outputFormat;
+            const fmt = (outputFormat ?? 'json').toLowerCase();
+            if (fmt === 'csv')
+                return await nasaGetText("https://openaltimetry.earthdatacloud.nasa.gov/data", `/api/icesat2/getTracks`, { query });
+            return await nasaGet("https://openaltimetry.earthdatacloud.nasa.gov/data", `/api/icesat2/getTracks`, { query });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get icesat2 tracks");
+        }
+    },
+});
+export const nasaGetLevel3Data = tool({
+    description: "Tool to access ICESat-2 Level-3A product data from OpenAltimetry. Use when you need satellite altimetry measurements for land ice, sea ice, vegetation, ocean surface, or inland water surface heights. Requests are limited to 5x5 degree spatial bounding box selection and up to 1 year of data. Note: This endpoint is marked as COMING SOON in documentation but is functionally operational.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        maxx: z.number().describe("Maximum longitude (x-coordinate) for the bounding box in decimal degrees. Must define a bounding box no larger than 5x5 degrees."),
+        maxy: z.number().describe("Maximum latitude (y-coordinate) for the bounding box in decimal degrees. Must define a bounding box no larger than 5x5 degrees."),
+        minx: z.number().describe("Minimum longitude (x-coordinate) for the bounding box in decimal degrees. Must define a bounding box no larger than 5x5 degrees."),
+        miny: z.number().describe("Minimum latitude (y-coordinate) for the bounding box in decimal degrees. Must define a bounding box no larger than 5x5 degrees."),
+        client: z.string().optional().describe("Referring client identifier for API usage tracking purposes."),
+        endDate: z.string().optional().describe("End date for temporal filtering in YYYY-MM-DD format. Filters data to include only observations on or before this date."),
+        product: z.enum(["atl06", "atl07", "atl08", "atl10", "atl12", "atl13"]).describe("ICESat-2 data product type to retrieve. Options: atl06 (Land Ice Height), atl07 (Sea Ice Height), atl08 (Land and Vegetation Height), atl10 (Sea Ice Freeboard), atl12 (Ocean Surface Height), atl13 (Inland Water Surface Height)."),
+        trackId: z.number().int().describe("Reference ground track ID for ICESat-2 satellite track to retrieve data from."),
+        beamNames: z.array(z.string()).optional().describe("List of specific beam names to filter results. ICESat-2 has 6 beams: gt1l, gt1r, gt2l, gt2r, gt3l, gt3r."),
+        startDate: z.string().optional().describe("Start date for temporal filtering in YYYY-MM-DD format. Filters data to include only observations on or after this date."),
+        outputFormat: z.enum(["csv", "json", "zip"]).optional().describe("Output format for the Level-3A data."),
+        date: z.string().optional().describe("Date in YYYY-MM-DD format. Defaults to startDate when omitted."),
+    }),
+    execute: async ({ nasaApiKey, product, minx, miny, maxx, maxy, trackId, client, endDate, beamNames, startDate, outputFormat, date }) => {
+        try {
+            const query = {};
+            if (date !== undefined)
+                query["date"] = date;
+            if (minx !== undefined)
+                query["minx"] = minx;
+            if (miny !== undefined)
+                query["miny"] = miny;
+            if (maxx !== undefined)
+                query["maxx"] = maxx;
+            if (maxy !== undefined)
+                query["maxy"] = maxy;
+            if (trackId !== undefined)
+                query["trackId"] = trackId;
+            if (outputFormat !== undefined)
+                query["outputFormat"] = outputFormat;
+            if (client !== undefined)
+                query["client"] = client;
+            if (startDate !== undefined)
+                query["startDate"] = startDate;
+            if (endDate !== undefined)
+                query["endDate"] = endDate;
+            if (date !== undefined)
+                query["date"] = date;
+            else if (startDate !== undefined)
+                query["date"] = startDate;
+            if (beamNames !== undefined)
+                query['beamNames'] = beamNames.join(',');
+            const fmt = String(outputFormat ?? 'json').toLowerCase();
+            if (fmt === 'json')
+                return await nasaGet("https://openaltimetry.earthdatacloud.nasa.gov/data", `/api/icesat2/${enc(product)}`, { query });
+            return await nasaGetText("https://openaltimetry.earthdatacloud.nasa.gov/data", `/api/icesat2/${enc(product)}`, { query });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get level3 data");
+        }
+    },
+});
+//# sourceMappingURL=icesat2.js.map

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

@@ -0,0 +1,36 @@
+export declare const nasaGetTechportProject: import("ai").Tool<{
+    id: number;
+    nasaApiKey?: string | undefined;
+}, any>;
+export declare const nasaQueryExoplanetArchive: import("ai").Tool<{
+    table: string;
+    order?: string | undefined;
+    where?: string | undefined;
+    select?: string | undefined;
+    format?: "json" | "ascii" | "csv" | "ipac" | undefined;
+    nasaApiKey?: string | undefined;
+}, any>;
+export declare const nasaSearchTechtransferSoftware: import("ai").Tool<{
+    keywords?: string | undefined;
+    nasaApiKey?: string | undefined;
+}, any>;
+export declare const nasaGetImageAsset: import("ai").Tool<{
+    nasaId: string;
+    nasaApiKey?: string | undefined;
+}, any>;
+export declare const nasaGetImageMetadata: import("ai").Tool<{
+    nasaId: string;
+    nasaApiKey?: string | undefined;
+}, any>;
+export declare const nasaGetVideoCaptions: import("ai").Tool<{
+    nasaId: string;
+    nasaApiKey?: string | undefined;
+}, any>;
+export declare const nasaSearchSvsVisualizations: import("ai").Tool<{
+    limit?: any;
+    search?: string | undefined;
+    offset?: number | undefined;
+    nasaApiKey?: string | undefined;
+    missions?: string[] | undefined;
+}, any>;
+//# sourceMappingURL=imagery.d.ts.map

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

@@ -0,0 +1,138 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { nasaGet, toNasaError, requireApiKey, enc, tapSync } from './client.js';
+export const nasaGetTechportProject = tool({
+    description: "Retrieves detailed information about a specific NASA technology project from TechPort. Returns comprehensive project data including title, description, benefits, status, program details, contacts, organizations, and technology readiness levels. Use this when you need information about a specific NASA technology project by its TechPort ID.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        id: z.number().int().describe("TechPort project ID. This is the unique identifier for the NASA technology project."),
+    }),
+    execute: async ({ nasaApiKey, id }) => {
+        const missing = requireApiKey(nasaApiKey);
+        if (missing)
+            return missing;
+        try {
+            const query = {};
+            query['api_key'] = nasaApiKey;
+            return await nasaGet("https://api.nasa.gov", `/techport/api/projects/${enc(id)}`, { query });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get techport project");
+        }
+    },
+});
+export const nasaQueryExoplanetArchive = tool({
+    description: "Tool to query NASA's Exoplanet Archive NSTED API for exoplanet and related astronomical data. Use when you need to search, filter, or retrieve data about confirmed exoplanets, Kepler Objects of Interest (KOIs), planetary systems, or composite planet parameters. Supports SQL-like filtering, column selection, sorting, and multiple output formats (JSON, CSV, ASCII, IPAC).",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        order: z.string().optional().describe("Column name to sort results by, optionally followed by 'desc' for descending order (e.g., 'koi_period', 'koi_period desc'). Defaults to ascending order if 'desc' is not specified."),
+        table: z.string().describe("Specifies which data table to query. Common tables: 'cumulative' (Kepler cumulative table), 'exoplanets' (confirmed exoplanets), 'ps' (planetary systems), 'koi' (Kepler Objects of Interest), 'compositepars' (composite planet parameters)."),
+        where: z.string().optional().describe("SQL-like filter conditions to narrow results (e.g., 'koi_period>300 and koi_prad<2', 'pl_masse>1.0'). Supports comparison operators (<, >, <=, >=, =, !=) and logical operators (and, or)."),
+        format: z.enum(["csv", "json", "ascii", "ipac"]).optional().describe("Output format for exoplanet data."),
+        select: z.string().optional().describe("Comma-separated list of column names to return (e.g., 'pl_hostname,ra,dec,pl_orbper'). Use '*' to return all columns. If omitted, returns all columns by default."),
+    }),
+    execute: async ({ nasaApiKey, table, order, where, format, select }) => {
+        try {
+            return await tapSync({ table, where, select, order, format: format ?? 'json' });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to query exoplanet archive");
+        }
+    },
+});
+export const nasaSearchTechtransferSoftware = tool({
+    description: "Search NASA's Technology Transfer software catalog for available tools and applications. Returns software entries with titles, descriptions, NASA case numbers, and licensing information. Use this when searching for NASA software tools available for public use, licensing, or download.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        keywords: z.string().optional().describe("Search keywords to filter the software catalog. If not provided, returns all available software entries. Examples: 'visualization', 'machine learning', 'data processing'."),
+    }),
+    execute: async ({ nasaApiKey, keywords }) => {
+        const missing = requireApiKey(nasaApiKey);
+        if (missing)
+            return missing;
+        try {
+            const query = {};
+            if (keywords !== undefined)
+                query["keywords"] = keywords;
+            query['api_key'] = nasaApiKey;
+            return await nasaGet("https://api.nasa.gov", `/techtransfer/software/`, { query });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to search techtransfer software");
+        }
+    },
+});
+export const nasaGetImageAsset = tool({
+    description: "Retrieve a media asset's manifest from the NASA Image and Video Library, including links to all available sizes and formats. Returns URLs for different image sizes (original, large, medium, small, thumbnail) and metadata. Use when you need to access specific media files after finding them through search.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        nasaId: z.string().describe("NASA ID of the media item to retrieve the asset manifest for (e.g., 'as11-40-5874'). This ID can be obtained from search results."),
+    }),
+    execute: async ({ nasaApiKey, nasaId }) => {
+        try {
+            return await nasaGet("https://images-api.nasa.gov", `/asset/${enc(nasaId)}`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get image asset");
+        }
+    },
+});
+export const nasaGetImageMetadata = tool({
+    description: "Retrieve the location URL of a media asset's metadata manifest from the NASA Image and Video Library. Returns the URL to the metadata JSON file containing detailed information including EXIF/camera data. Use when you need to access comprehensive metadata for NASA images or videos.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        nasaId: z.string().describe("NASA ID of the media item to retrieve the metadata location for (e.g., 'as11-40-5874'). This ID can be obtained from search results."),
+    }),
+    execute: async ({ nasaApiKey, nasaId }) => {
+        try {
+            return await nasaGet("https://images-api.nasa.gov", `/metadata/${enc(nasaId)}`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get image metadata");
+        }
+    },
+});
+export const nasaGetVideoCaptions = tool({
+    description: "Retrieves the location URL of caption files for NASA video assets from the NASA Image and Video Library. Returns the URL to the captions file (typically in SRT format) for the specified video NASA ID. Use this when you need to access subtitles or captions for NASA video content.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        nasaId: z.string().describe("NASA ID of the video for which to retrieve captions. This is typically the video title or identifier (e.g., 'Apollo 14 Launch Coverage')."),
+    }),
+    execute: async ({ nasaApiKey, nasaId }) => {
+        try {
+            return await nasaGet("https://images-api.nasa.gov", `/captions/${enc(nasaId)}`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get video captions");
+        }
+    },
+});
+export const nasaSearchSvsVisualizations = tool({
+    description: "Tool to search for visualizations in the Scientific Visualization Studio (SVS). Use when you need to query SVS visualizations by keywords or mission filters.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        limit: z.any().optional().describe("Maximum number of results to return. Use an integer up to 2000, or 'all'/'none' to fetch all available results."),
+        offset: z.number().int().min(0).optional().describe("Number of initial results to skip (for pagination)."),
+        search: z.string().optional().describe("Free-text term to search titles and descriptions (e.g. 'Apollo')."),
+        missions: z.array(z.string()).optional().describe("List of mission names to filter results. Multiple values will be joined with commas (e.g., ['JWST', 'Hubble'])."),
+    }),
+    execute: async ({ nasaApiKey, limit, offset, search, missions }) => {
+        try {
+            const query = {};
+            if (search !== undefined)
+                query["search"] = search;
+            if (missions !== undefined)
+                query["missions"] = missions;
+            if (limit !== undefined)
+                query["limit"] = limit;
+            if (offset !== undefined)
+                query["offset"] = offset;
+            return await nasaGet("https://svs.gsfc.nasa.gov", `/api/search/`, { query });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to search svs visualizations");
+        }
+    },
+});
+//# sourceMappingURL=imagery.js.map