@rnsk/toolkits 0.0.10 → 0.0.12

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

@@ -0,0 +1,176 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { nasaGet, nasaDownloadMeta, toNasaError, enc } from './client.js';
+export const nasaGetAgageData = tool({
+    description: "Tool to retrieve information about AGAGE (Advanced Global Atmospheric Gases Experiment) data files. Returns paginated results (40 files per page) with detailed metadata including compound names, stations, dates, instruments, and file locations. Use when you need to search or browse AGAGE atmospheric data files. Supports filtering by recommendation status, compounds, stations, date ranges, and other criteria.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        page: z.number().int().min(1).optional().describe("Page number for paginated results. Each page returns 40 data files. Must be 1 or greater."),
+        order: z.string().optional().describe("Primary sort order for results. Valid values: 'compound_display_order', 'station_display_order', 'data_date', 'upload_date', 'compound_name', 'file_name', 'product_type_name', 'data_frequency_name', 'instrument_names', 'station_name', 'version_name'. Secondary sort is always by station display_order. Defaults to 'compound_display_order'."),
+        station: z.string().optional().describe("One or more comma-separated station IDs to filter by (e.g., '16')."),
+        version: z.string().optional().describe("One or more comma-separated version IDs to filter by (e.g., '1')."),
+        compound: z.string().optional().describe("One or more comma-separated compound IDs to filter by (e.g., '14' or '14,15,16')."),
+        maxDate: z.string().optional().describe("Exclude all data after this date. Format: YYYY-MM-DD (e.g., '2030-05-01')."),
+        minDate: z.string().optional().describe("Exclude all data before this date. Format: YYYY-MM-DD (e.g., '2021-05-01')."),
+        instrument: z.string().optional().describe("One or more comma-separated instrument IDs to filter by (e.g., '6')."),
+        recommended: z.boolean().optional().describe("Filter by recommendation status. If true, returns only files recommended by the AGAGE team. If false, returns non-recommended files. If omitted, returns all files regardless of recommendation status."),
+        productType: z.string().optional().describe("One or more comma-separated product type IDs to filter by (e.g., '1' or '1,2')."),
+        dataFrequency: z.string().optional().describe("One or more comma-separated data frequency IDs to filter by (e.g., '1')."),
+        orderDirection: z.string().optional().describe("Sort direction for the order parameter. Valid values: 'asc' (ascending) or 'desc' (descending). Defaults to 'desc'."),
+    }),
+    execute: async ({ nasaApiKey, page, order, station, version, compound, maxDate, minDate, instrument, recommended, productType, dataFrequency, orderDirection }) => {
+        try {
+            const query = {};
+            if (compound !== undefined)
+                query["compound"] = compound;
+            if (productType !== undefined)
+                query["product_type"] = productType;
+            if (dataFrequency !== undefined)
+                query["data_frequency"] = dataFrequency;
+            if (instrument !== undefined)
+                query["instrument"] = instrument;
+            if (version !== undefined)
+                query["version"] = version;
+            if (station !== undefined)
+                query["station"] = station;
+            if (minDate !== undefined)
+                query["min_date"] = minDate;
+            if (maxDate !== undefined)
+                query["max_date"] = maxDate;
+            if (recommended !== undefined)
+                query["recommended"] = recommended;
+            if (order !== undefined)
+                query["order"] = order;
+            if (orderDirection !== undefined)
+                query["order_direction"] = orderDirection;
+            return await nasaGet("https://www-air.larc.nasa.gov/missions/agage/api", `/data/${page ?? 1}`, { query });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get agage data");
+        }
+    },
+});
+export const nasaGetAgageDataByFileName = tool({
+    description: "Search for AGAGE (Advanced Global Atmospheric Gases Experiment) data files by file name. Returns detailed metadata about matching files including compound information, station details, temporal coverage, geographic coordinates, and file properties. Use this when you need to find specific AGAGE data files or retrieve metadata about atmospheric gas measurements.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        fileName: z.string().describe("The name of the file to search for. Can be a full filename (e.g., 'agage_adr_ch3ccl3_git-baseline-20250123.nc') or a partial name depending on match_type."),
+        matchType: z.enum(["exact_match", "begins_with", "ends_with"]).optional().describe("Match type for file name search."),
+    }),
+    execute: async ({ nasaApiKey, fileName, matchType }) => {
+        try {
+            const query = {};
+            if (fileName !== undefined)
+                query["file_name"] = fileName;
+            if (matchType !== undefined)
+                query["match_type"] = matchType;
+            return await nasaGet("https://www-air.larc.nasa.gov/missions/agage/api", `/data/search_by_file_name`, { query });
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get agage data by file name");
+        }
+    },
+});
+export const nasaGetAgageDataJsonForGraph = tool({
+    description: "Retrieve AGAGE atmospheric composition data in JSON format optimized for graphing. Returns time series data including O3_Number_Density and other trace gas measurements with start/stop dates. Use this when you need to visualize or analyze atmospheric composition trends from NASA's Advanced Global Atmospheric Gases Experiment (AGAGE) network.",
+    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().min(1).describe("Data ID associated with one hi-res AGAGE file. Use this to retrieve specific atmospheric composition measurements."),
+    }),
+    execute: async ({ nasaApiKey, id }) => {
+        try {
+            return await nasaGet("https://www-air.larc.nasa.gov/missions/agage/api", `/data/json_for_graph/${enc(id)}`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get agage data json for graph");
+        }
+    },
+});
+export const nasaGetAgageDataDownload = tool({
+    description: "Download AGAGE (Advanced Global Atmospheric Gases Experiment) data files by ID. Accepts up to 35 comma-separated data IDs in a single request. Returns the requested data file(s) as a downloadable binary file. Use this when you need to retrieve specific AGAGE atmospheric measurement datasets.",
+    inputSchema: z.object({
+        nasaApiKey: z.string().optional().describe("NASA API key (injected when connected; only sent to api.nasa.gov endpoints)"),
+        ids: z.string().describe("A comma-delimited list of data IDs to download (e.g., '1127' or '1127,1128,1129'). Maximum 35 IDs per request. Each ID corresponds to a specific AGAGE dataset file."),
+    }),
+    execute: async ({ nasaApiKey, ids }) => {
+        try {
+            const headers = {};
+            return await nasaDownloadMeta("https://www-air.larc.nasa.gov/missions/agage/api", `/data/download/${enc(ids)}`, headers);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get agage data download");
+        }
+    },
+});
+export const nasaGetAgageDataVersions = tool({
+    description: "Tool to retrieve information on all AGAGE (Advanced Global Atmospheric Gases Experiment) data versions. Use when you need version details, DOIs, citations, or descriptions for the NASA AGAGE dataset archive.",
+    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://www-air.larc.nasa.gov/missions/agage/api", `/data/versions`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get agage data versions");
+        }
+    },
+});
+export const nasaGetCompounds = tool({
+    description: "Tool to retrieve information on all data compounds available in NASA's AGAGE (Advanced Global Atmospheric Gases Experiment) API. Use when you need to discover available chemical compounds, their identifiers, and descriptions.",
+    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://www-air.larc.nasa.gov/missions/agage/api", `/data/compounds`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get compounds");
+        }
+    },
+});
+export const nasaGetStations = tool({
+    description: "Tool to retrieve information on all AGAGE (Advanced Global Atmospheric Gases Experiment) data stations. Use when you need station names, locations, coordinates, elevation, or other metadata about monitoring sites.",
+    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://www-air.larc.nasa.gov/missions/agage/api", `/data/stations`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get stations");
+        }
+    },
+});
+export const nasaGetDataFrequencies = tool({
+    description: "Retrieves all available data frequency options from NASA's AGAGE (Advanced Global Atmospheric Gases Experiment) mission. Data frequencies define the measurement intervals for atmospheric data collection (e.g., hourly, daily). Use this tool to: - Discover available measurement frequencies for AGAGE data - Get frequency IDs for filtering atmospheric gas data by sampling rate - Understand what each frequency option represents No parameters required - returns all available data frequencies.",
+    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://www-air.larc.nasa.gov/missions/agage/api", `/data/data_frequencies`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get data frequencies");
+        }
+    },
+});
+export const nasaGetProcessingTypes = tool({
+    description: "Tool to retrieve information on all data instruments from NASA's AGAGE mission. Use when you need to list available instruments with their IDs, names, and descriptions.",
+    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://www-air.larc.nasa.gov/missions/agage/api", `/data/instruments`);
+        }
+        catch (error) {
+            return toNasaError(error, "Failed to get processing types");
+        }
+    },
+});
+//# sourceMappingURL=agage.js.map

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

@@ -0,0 +1,95 @@
+export declare class NasaApiError extends Error {
+    status: number;
+    details: unknown;
+    constructor(message: string, status: number, details: unknown);
+}
+export declare function enc(value: string | number): string;
+export declare function appendQuery(url: URL, query?: Record<string, unknown>): void;
+export declare function nasaGet(base: string, path: string, options?: {
+    query?: Record<string, unknown>;
+}): Promise<any>;
+export declare function nasaGetText(base: string, path: string, options?: {
+    query?: Record<string, unknown>;
+}): Promise<{
+    format: string;
+    content: string;
+}>;
+export declare function nasaPost(base: string, path: string, body: unknown): Promise<any>;
+export declare function nasaDownloadMeta(base: string, path: string, headers?: Record<string, string>): Promise<{
+    name: string;
+    mimetype: string | null;
+    sizeBytes: number | null;
+    url: string;
+    note: string;
+}>;
+export declare function toNasaError(error: unknown, label: string): {
+    error: string;
+    details: unknown;
+    statusCode: number;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    statusCode?: undefined;
+};
+export declare function requireApiKey(nasaApiKey: string | undefined): {
+    error: string;
+} | null;
+export declare function tapSync(options: {
+    table: string;
+    where?: string;
+    select?: string;
+    order?: string;
+    format?: string;
+}): Promise<any>;
+export declare function convertEonet(data: any, format: 'atom' | 'rss' | 'geojson'): any;
+/** Normalize a coordinate system name to the SSC API's case-sensitive enum. */
+export declare function sscCoordSys(value: string): string;
+/** Unwrap Jersey wrapper-array JSON encoding: ["com.ClassName", {...}] -> {...}. */
+export declare function unwrapJersey(value: any): any;
+export declare function sscGet(path: string, query?: Record<string, unknown>): Promise<any>;
+export declare function sscGraph(options: {
+    time_interval: {
+        start: string;
+        end: string;
+    };
+    satellites: Array<{
+        id: string;
+        resolution_factor?: number;
+    }>;
+    graph_options: {
+        coordinate_system: string;
+    };
+    description?: string;
+}): Promise<any>;
+export declare function sscLocations(options: {
+    time_interval: {
+        start: string;
+        end: string;
+    };
+    satellites: Array<{
+        satellite_id: string;
+        resolution_factor?: number;
+    }>;
+    b_field_model?: {
+        trace_stop_altitude?: number;
+        internal_b_field_model?: string;
+        external_b_field_model?: {
+            key_parameter_values?: string;
+        };
+    };
+    output_options?: {
+        coordinate_options: Array<{
+            coordinate_system: string;
+            component: string;
+        }>;
+    };
+    description?: string;
+}): Promise<any>;
+export declare function gqlArgsString(args: Record<string, unknown>): string;
+export declare function cmrGraphql(root: string, args: Record<string, unknown>, selection: string): Promise<any>;
+export declare function cmrGraphqlRaw(query: string): Promise<any>;
+export declare function cmrGraphqlMutation(name: string, args: Record<string, unknown>, selection: string): Promise<any>;
+export declare const CMR_GQL_URL = "https://graphql.earthdata.nasa.gov/api";
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,337 @@
+// @ts-nocheck
+export class NasaApiError extends Error {
+    status;
+    details;
+    constructor(message, status, details) {
+        super(message);
+        this.status = status;
+        this.details = details;
+    }
+}
+export function enc(value) {
+    return encodeURIComponent(String(value));
+}
+export function appendQuery(url, query) {
+    if (!query)
+        return;
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined || value === null)
+            continue;
+        url.searchParams.set(key, String(value));
+    }
+}
+async function parseBody(response) {
+    const contentType = response.headers.get('content-type') ?? '';
+    const text = await response.text();
+    if (text) {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            // not JSON below
+        }
+    }
+    else {
+        return {};
+    }
+    if (contentType.includes('xml') || text.trimStart().startsWith('<')) {
+        return { xml: text };
+    }
+    return { raw: text };
+}
+export async function nasaGet(base, path, options) {
+    const url = new URL(`${base}${path}`);
+    appendQuery(url, options?.query);
+    const response = await fetch(url.toString(), { headers: { Accept: 'application/json' } });
+    const data = await parseBody(response);
+    if (!response.ok) {
+        throw new NasaApiError('NASA API request failed', response.status, data);
+    }
+    return data;
+}
+export async function nasaGetText(base, path, options) {
+    const url = new URL(`${base}${path}`);
+    appendQuery(url, options?.query);
+    const response = await fetch(url.toString());
+    const text = await response.text();
+    if (!response.ok) {
+        throw new NasaApiError('NASA API request failed', response.status, { raw: text.slice(0, 2000) });
+    }
+    return { format: 'text', content: text };
+}
+export async function nasaPost(base, path, body) {
+    const response = await fetch(`${base}${path}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+        body: JSON.stringify(body),
+    });
+    const data = await parseBody(response);
+    if (!response.ok) {
+        throw new NasaApiError('NASA API request failed', response.status, data);
+    }
+    return data;
+}
+export async function nasaDownloadMeta(base, path, headers) {
+    const url = `${base}${path}`;
+    const response = await fetch(url, { method: 'HEAD', headers });
+    if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        throw new NasaApiError('NASA API request failed', response.status, { raw: body.slice(0, 2000) });
+    }
+    const length = response.headers.get('content-length');
+    return {
+        name: path.split('/').pop() ?? 'download',
+        mimetype: response.headers.get('content-type'),
+        sizeBytes: length ? Number(length) : null,
+        url,
+        note: 'Binary content is not embedded in tool output. Use the url to download the file directly.',
+    };
+}
+export function toNasaError(error, label) {
+    if (error instanceof NasaApiError) {
+        return { error: label, details: error.details, statusCode: error.status };
+    }
+    return {
+        error: label.replace('Failed', 'Error').replace('failed', 'error'),
+        message: error instanceof Error ? error.message : 'Unknown error',
+    };
+}
+export function requireApiKey(nasaApiKey) {
+    if (!nasaApiKey) {
+        return { error: 'NASA API key is required. Connect NASA first.' };
+    }
+    return null;
+}
+// ---------- Exoplanet TAP ----------
+const EXO_TABLES = {
+    cumulative: 'CUMULATIVE',
+    exoplanets: 'ps',
+    ps: 'ps',
+    koi: 'Q1_Q17_DR25_KOI',
+    compositepars: 'pscomppars',
+};
+export async function tapSync(options) {
+    const mapped = EXO_TABLES[options.table] ?? options.table;
+    const format = (options.format ?? 'json').toLowerCase();
+    let adql = `select ${options.select || '*'} from ${mapped}`;
+    if (options.where)
+        adql += ` where ${options.where}`;
+    if (options.order)
+        adql += ` order by ${options.order}`;
+    const url = new URL('https://exoplanetarchive.ipac.caltech.edu/TAP/sync');
+    url.searchParams.set('query', adql);
+    url.searchParams.set('format', format);
+    const response = await fetch(url.toString());
+    const text = await response.text();
+    if (!response.ok) {
+        throw new NasaApiError('NASA API request failed', response.status, { raw: text.slice(0, 2000) });
+    }
+    if (format === 'json') {
+        try {
+            const data = JSON.parse(text);
+            return { format, recordCount: Array.isArray(data) ? data.length : undefined, data };
+        }
+        catch {
+            return { format, data: text };
+        }
+    }
+    return { format, data: text };
+}
+// ---------- EONET format converters (API only serves JSON) ----------
+function escapeXml(s) {
+    return String(s ?? '')
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+export function convertEonet(data, format) {
+    const events = Array.isArray(data?.events) ? data.events : [];
+    if (format === 'geojson') {
+        return {
+            type: 'FeatureCollection',
+            features: events.flatMap((e) => (e.geometry ?? []).map((g) => ({
+                type: 'Feature',
+                geometry: { type: g.type, coordinates: g.coordinates },
+                properties: {
+                    id: e.id,
+                    title: e.title,
+                    description: e.description,
+                    link: e.link,
+                    closed: e.closed,
+                    categories: e.categories,
+                    sources: e.sources,
+                    date: g.date,
+                    magnitudeValue: g.magnitudeValue,
+                    magnitudeUnit: g.magnitudeUnit,
+                },
+            }))),
+        };
+    }
+    const items = events
+        .map((e) => `  <entry>\n    <title>${escapeXml(e.title)}</title>\n    <id>${escapeXml(e.id)}</id>\n    <link href="${escapeXml(e.link)}"/>\n    <summary>${escapeXml(e.description ?? '')}</summary>\n  </entry>`)
+        .join('\n');
+    if (format === 'atom') {
+        return {
+            format: 'atom',
+            xml: `<?xml version="1.0" encoding="utf-8"?>\n<feed xmlns="http://www.w3.org/2005/Atom">\n  <title>${escapeXml(data?.title ?? 'EONET Events')}</title>\n${items}\n</feed>`,
+        };
+    }
+    const rssItems = events
+        .map((e) => `  <item>\n    <title>${escapeXml(e.title)}</title>\n    <guid>${escapeXml(e.id)}</guid>\n    <link>${escapeXml(e.link)}</link>\n    <description>${escapeXml(e.description ?? '')}</description>\n  </item>`)
+        .join('\n');
+    return {
+        format: 'rss',
+        xml: `<?xml version="1.0" encoding="utf-8"?>\n<rss version="2.0" xmlns:georss="http://www.georss.org/georss">\n<channel>\n  <title>${escapeXml(data?.title ?? 'EONET Events')}</title>\n${rssItems}\n</channel>\n</rss>`,
+    };
+}
+// ---------- SSC (Satellite Situation Center) ----------
+const SSC_NS = 'http://sscweb.gsfc.nasa.gov/schema';
+function xmlEscape(s) {
+    return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+const SSC_COORDS = {
+    geo: 'Geo', gm: 'Gm', gse: 'Gse', gsm: 'Gsm', sm: 'Sm',
+    gei_tod: 'GeiTod', geitod: 'GeiTod', gei_j2000: 'GeiJ2000', geij2000: 'GeiJ2000',
+};
+/** Normalize a coordinate system name to the SSC API's case-sensitive enum. */
+export function sscCoordSys(value) {
+    const key = String(value).toLowerCase();
+    if (SSC_COORDS[key])
+        return SSC_COORDS[key];
+    const known = Object.values(SSC_COORDS).find((v) => v.toLowerCase() === key);
+    return known ?? String(value);
+}
+/** Unwrap Jersey wrapper-array JSON encoding: ["com.ClassName", {...}] -> {...}. */
+export function unwrapJersey(value) {
+    if (Array.isArray(value)) {
+        if (value.length === 2 && typeof value[0] === 'string' && value[0].includes('.')) {
+            return unwrapJersey(value[1]);
+        }
+        return value.map(unwrapJersey);
+    }
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const k of Object.keys(value))
+            out[k] = unwrapJersey(value[k]);
+        return out;
+    }
+    return value;
+}
+export async function sscGet(path, query) {
+    const url = new URL(`https://sscweb.gsfc.nasa.gov/WS/sscr/2${path}`);
+    appendQuery(url, query);
+    const response = await fetch(url.toString(), { headers: { Accept: 'application/json' } });
+    const data = await parseBody(response);
+    if (!response.ok) {
+        throw new NasaApiError('NASA API request failed', response.status, data);
+    }
+    return unwrapJersey(data);
+}
+export async function sscGraph(options) {
+    const sats = options.satellites
+        .map((s) => `<Satellites><Id>${xmlEscape(s.id)}</Id><ResolutionFactor>${s.resolution_factor ?? 1}</ResolutionFactor></Satellites>`)
+        .join('');
+    const xml = `<GraphRequest xmlns="${SSC_NS}">` +
+        `<TimeInterval><Start>${xmlEscape(options.time_interval.start)}</Start><End>${xmlEscape(options.time_interval.end)}</End></TimeInterval>` +
+        sats +
+        `<GraphOptions xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="OrbitGraphOptions">` +
+        `<CoordinateSystem>${xmlEscape(sscCoordSys(options.graph_options.coordinate_system))}</CoordinateSystem></GraphOptions>` +
+        `</GraphRequest>`;
+    const response = await fetch('https://sscweb.gsfc.nasa.gov/WS/sscr/2/graphs', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/xml', Accept: 'application/json' },
+        body: xml,
+    });
+    const data = await parseBody(response);
+    if (!response.ok) {
+        throw new NasaApiError('NASA API request failed', response.status, data);
+    }
+    return unwrapJersey(data);
+}
+export async function sscLocations(options) {
+    const sats = options.satellites
+        .map((s) => `<Satellites><Id>${xmlEscape(s.satellite_id)}</Id><ResolutionFactor>${s.resolution_factor ?? 2}</ResolutionFactor></Satellites>`)
+        .join('');
+    let bfield = '';
+    const bf = options.b_field_model;
+    if (bf) {
+        bfield =
+            '<BFieldModel>' +
+                (bf.internal_b_field_model ? `<InternalBFieldModel>${xmlEscape(bf.internal_b_field_model)}</InternalBFieldModel>` : '') +
+                (bf.external_b_field_model?.key_parameter_values
+                    ? `<ExternalBFieldModel><KeyParameterValues>${xmlEscape(bf.external_b_field_model.key_parameter_values)}</KeyParameterValues></ExternalBFieldModel>`
+                    : '') +
+                (bf.trace_stop_altitude !== undefined ? `<TraceStopAltitude>${bf.trace_stop_altitude}</TraceStopAltitude>` : '') +
+                '</BFieldModel>';
+    }
+    let output = '';
+    const oo = options.output_options;
+    if (oo?.coordinate_options?.length) {
+        const coords = oo.coordinate_options
+            .map((c) => `<CoordinateOptions><CoordinateSystem>${xmlEscape(sscCoordSys(c.coordinate_system))}</CoordinateSystem><Component>${xmlEscape(String(c.component).toUpperCase())}</Component></CoordinateOptions>`)
+            .join('');
+        output = `<OutputOptions>${coords}</OutputOptions>`;
+    }
+    const xml = `<DataRequest xmlns="${SSC_NS}">` +
+        `<TimeInterval><Start>${xmlEscape(options.time_interval.start)}</Start><End>${xmlEscape(options.time_interval.end)}</End></TimeInterval>` +
+        sats +
+        bfield +
+        output +
+        `</DataRequest>`;
+    const response = await fetch('https://sscweb.gsfc.nasa.gov/WS/sscr/2/locations', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/xml', Accept: 'application/json' },
+        body: xml,
+    });
+    const data = await parseBody(response);
+    if (!response.ok) {
+        throw new NasaApiError('NASA API request failed', response.status, data);
+    }
+    return unwrapJersey(data);
+}
+// ---------- CMR GraphQL ----------
+const CMR_GQL = 'https://graphql.earthdata.nasa.gov/api';
+function gqlValue(value) {
+    if (value === null || value === undefined)
+        return 'null';
+    if (Array.isArray(value))
+        return `[${value.map(gqlValue).join(', ')}]`;
+    if (typeof value === 'object') {
+        return `{${Object.entries(value)
+            .filter(([, v]) => v !== undefined)
+            .map(([k, v]) => `${k}: ${gqlValue(v)}`)
+            .join(', ')}}`;
+    }
+    if (typeof value === 'string')
+        return JSON.stringify(value);
+    return String(value);
+}
+export function gqlArgsString(args) {
+    const parts = Object.entries(args)
+        .filter(([, v]) => v !== undefined)
+        .map(([k, v]) => `${k}: ${gqlValue(v)}`);
+    return parts.length ? `(params: {${parts.join(', ')}})` : '';
+}
+async function cmrGqlPost(query) {
+    const data = await nasaPost('https://graphql.earthdata.nasa.gov', '/api', { query });
+    if (data?.errors?.length) {
+        throw new NasaApiError('NASA CMR GraphQL query failed', 200, data.errors);
+    }
+    return data?.data ?? data;
+}
+export async function cmrGraphql(root, args, selection) {
+    return cmrGqlPost(`query { ${root}${gqlArgsString(args)} ${selection} }`);
+}
+export async function cmrGraphqlRaw(query) {
+    const data = await nasaPost('https://graphql.earthdata.nasa.gov', '/api', { query });
+    return data;
+}
+export async function cmrGraphqlMutation(name, args, selection) {
+    const parts = Object.entries(args)
+        .filter(([, v]) => v !== undefined)
+        .map(([k, v]) => `${k}: ${gqlValue(v)}`);
+    return cmrGqlPost(`mutation { ${name}${parts.length ? `(${parts.join(', ')})` : ''} ${selection} }`);
+}
+export const CMR_GQL_URL = CMR_GQL;
+//# sourceMappingURL=client.js.map