@tiangong-lca/mcp-server 0.0.28 → 0.0.31

package/README.md

@@ -4,6 +4,15 @@
 
 TianGong LCA Model Context Protocol (MCP) Server supports STDIO and Streamable Http protocols.
 
+## Environment
+
+GLAD dataset search tools require a GLAD API key in the server environment:
+
+```bash
+GLAD_API_KEY=your-glad-api-key
+GLAD_API_BASE_URL=https://www.globallcadataaccess.org/api/v1
+```
+
 ## Starting MCP Server
 
 ### Client STDIO Server

package/dist/src/_shared/config.js

@@ -10,3 +10,5 @@ export const supabase_publishable_key = process.env.SUPABASE_PUBLISHABLE_KEY ??
 export const x_region = process.env.X_REGION ?? 'us-east-1';
 export const redis_url = process.env.UPSTASH_REDIS_URL ?? '';
 export const redis_token = process.env.UPSTASH_REDIS_TOKEN ?? '';
+export const glad_api_base_url = process.env.GLAD_API_BASE_URL ?? 'https://www.globallcadataaccess.org/api/v1';
+export const glad_api_key = process.env.GLAD_API_KEY ?? '';

package/dist/src/_shared/init_server.js

@@ -2,6 +2,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { regOpenLcaPrompts } from '../prompts/lca_calculation.js';
 import { regOpenLcaResources } from '../resources/lca_calculation.js';
 import { regFlowSearchTool } from '../tools/flow_hybrid_search.js';
+import { regGladDatasetTools } from '../tools/glad_dataset_search.js';
 import { regLcaCalculationGuidanceTool } from '../tools/lca_calculation_guidance.js';
 import { regLifecycleModelSearchTool } from '../tools/life_cycle_model_hybrid_search.js';
 import { regOpenLcaLciaTool } from '../tools/openlca_ipc_lcia.js';
@@ -16,6 +17,7 @@ export function initializeServer(bearerKey) {
     regFlowSearchTool(server, bearerKey);
     regProcessSearchTool(server, bearerKey);
     regLifecycleModelSearchTool(server, bearerKey);
+    regGladDatasetTools(server);
     regOpenLcaLciaTool(server);
     regOpenLcaListSystemProcessesTool(server);
     regOpenLcaListLCIAMethodsTool(server);

package/dist/src/_shared/init_server_http.js

@@ -1,6 +1,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { regCrudTool } from '../tools/db_crud.js';
 import { regFlowSearchTool } from '../tools/flow_hybrid_search.js';
+import { regGladDatasetTools } from '../tools/glad_dataset_search.js';
 import { regLifecycleModelSearchTool } from '../tools/life_cycle_model_hybrid_search.js';
 import { regProcessSearchTool } from '../tools/process_hybrid_search.js';
 export function initializeServer(bearerKey, supabaseSession) {
@@ -11,6 +12,7 @@ export function initializeServer(bearerKey, supabaseSession) {
     regFlowSearchTool(server, bearerKey);
     regProcessSearchTool(server, bearerKey);
     regLifecycleModelSearchTool(server, bearerKey);
+    regGladDatasetTools(server);
     regCrudTool(server, supabaseSession ?? bearerKey);
     return server;
 }

package/dist/src/tools/db_crud.js

@@ -1,10 +1,10 @@
-import { createClient, FunctionRegion } from '@supabase/supabase-js';
+import { createClient } from '@supabase/supabase-js';
 import { z } from 'zod';
 import { supabase_base_url, supabase_publishable_key } from '../_shared/config.js';
 import { resolveSupabaseAccessToken } from '../_shared/supabase_session.js';
+import { prepareLifecycleModelFile } from './life_cycle_model_file_tools.js';
 const allowedTables = ['contacts', 'flows', 'lifecyclemodels', 'processes', 'sources'];
 const tableSchema = z.enum(allowedTables);
-const UPDATE_FUNCTION_NAME = 'update_data';
 const MAX_VALIDATION_ERROR_LENGTH = 4_000;
 const tablePrimaryKey = {
     contacts: 'id',
@@ -50,7 +50,7 @@ const toolParamsSchema = {
     jsonOrdered: z
         .unknown()
         .optional()
-        .describe('JSON value persisted into json_ordered (required for insert/update; omit for select/delete).'),
+        .describe('JSON value persisted into json_ordered (required for insert/update; omit for select/delete). For lifecyclemodels, native files, platform bundles, raw records, or a single-item array of those are accepted; json_tg and rule_verification are derived automatically before write.'),
 };
 const refinedInputSchema = z
     .object(toolParamsSchema)
@@ -175,6 +175,51 @@ async function validateJsonOrdered(table, jsonOrdered) {
         throw error;
     }
 }
+function sanitizeLifecycleModelRows(rows) {
+    return rows.map((row) => {
+        const record = row && typeof row === 'object' && !Array.isArray(row)
+            ? row
+            : {};
+        return {
+            id: record.id ?? null,
+            version: record.version ?? null,
+            json_ordered: record.json_ordered ?? null,
+        };
+    });
+}
+function sanitizeRowsForOutput(table, rows) {
+    return table === 'lifecyclemodels' ? sanitizeLifecycleModelRows(rows) : rows;
+}
+async function prepareWritePayload(table, jsonOrdered, inputId, inputVersion, bearerKey) {
+    if (table !== 'lifecyclemodels') {
+        await validateJsonOrdered(table, jsonOrdered);
+        return {
+            payload: {
+                json_ordered: jsonOrdered,
+            },
+            resolvedId: inputId,
+            resolvedVersion: inputVersion,
+        };
+    }
+    const prepared = await prepareLifecycleModelFile({
+        payload: jsonOrdered,
+    }, bearerKey);
+    if (inputId && inputId !== prepared.lifecycleModelId) {
+        throw new Error(`Provided id (${inputId}) does not match lifecycle model UUID (${prepared.lifecycleModelId}).`);
+    }
+    if (inputVersion && inputVersion !== prepared.lifecycleModelVersion) {
+        throw new Error(`Provided version (${inputVersion}) does not match lifecycle model version (${prepared.lifecycleModelVersion}).`);
+    }
+    return {
+        payload: {
+            json_ordered: prepared.jsonOrdered,
+            json_tg: prepared.jsonTg,
+            rule_verification: prepared.ruleVerification,
+        },
+        resolvedId: prepared.lifecycleModelId,
+        resolvedVersion: prepared.lifecycleModelVersion,
+    };
+}
 async function createSupabaseClient(bearerKey) {
     const { session: normalizedSession, accessToken: bearerToken } = resolveSupabaseAccessToken(bearerKey);
     const supabase = createClient(supabase_base_url, supabase_publishable_key, {
@@ -206,7 +251,8 @@ async function createSupabaseClient(bearerKey) {
 async function handleSelect(supabase, input) {
     const { table, limit, id, version, filters } = input;
     const keyColumn = getPrimaryKeyColumn(table);
-    let queryBuilder = supabase.from(table).select('*');
+    const selectColumns = table === 'lifecyclemodels' ? 'id, version, json_ordered' : '*';
+    let queryBuilder = supabase.from(table).select(selectColumns);
     if (filters) {
         for (const [column, value] of Object.entries(filters)) {
             if (value !== null && value !== undefined) {
@@ -228,10 +274,11 @@ async function handleSelect(supabase, input) {
         console.error('Error querying the database:', error);
         throw error;
     }
-    return JSON.stringify({ data: data ?? [], count: data?.length ?? 0 });
+    const rows = sanitizeRowsForOutput(table, (data ?? []));
+    return JSON.stringify({ data: rows, count: rows.length });
 }
-async function handleInsert(supabase, input) {
-    const { table, jsonOrdered, id } = input;
+async function handleInsert(supabase, input, bearerKey) {
+    const { table, jsonOrdered, id, version } = input;
     if (jsonOrdered === undefined) {
         throw new Error('jsonOrdered is required for insert operations.');
     }
@@ -239,19 +286,28 @@ async function handleInsert(supabase, input) {
         throw new Error('id is required for insert operations.');
     }
     const jsonOrderedValue = jsonOrdered;
-    await validateJsonOrdered(table, jsonOrderedValue);
+    const preparedWrite = await prepareWritePayload(table, jsonOrderedValue, id, version, bearerKey);
+    const resolvedId = preparedWrite.resolvedId ?? id;
+    const resolvedVersion = preparedWrite.resolvedVersion ?? version;
     const keyColumn = getPrimaryKeyColumn(table);
     const { data, error } = await supabase
         .from(table)
-        .insert([{ [keyColumn]: id, json_ordered: jsonOrderedValue }])
+        .insert([
+        {
+            [keyColumn]: resolvedId,
+            ...(resolvedVersion !== undefined ? { version: resolvedVersion } : {}),
+            ...preparedWrite.payload,
+        },
+    ])
         .select();
     if (error) {
         console.error('Error inserting into the database:', error);
         throw error;
     }
-    return JSON.stringify({ id, data: data ?? [] });
+    const rows = sanitizeRowsForOutput(table, (data ?? []));
+    return JSON.stringify({ id: resolvedId, version: resolvedVersion, data: rows });
 }
-async function handleUpdate(supabase, accessToken, input) {
+async function handleUpdate(supabase, accessToken, input, bearerKey) {
     const { table, id, version, jsonOrdered } = input;
     if (id === undefined) {
         throw new Error('id is required for update operations.');
@@ -263,29 +319,27 @@ async function handleUpdate(supabase, accessToken, input) {
         throw new Error('jsonOrdered is required for update operations.');
     }
     const jsonOrderedValue = jsonOrdered;
-    await validateJsonOrdered(table, jsonOrderedValue);
-    const token = requireAccessToken(accessToken);
-    const { data: functionPayload, error } = await supabase.functions.invoke(UPDATE_FUNCTION_NAME, {
-        headers: {
-            Authorization: `Bearer ${token}`,
-        },
-        body: { id, version, table, data: { json_ordered: jsonOrderedValue } },
-        region: FunctionRegion.UsEast1,
-    });
+    const preparedWrite = await prepareWritePayload(table, jsonOrderedValue, id, version, bearerKey);
+    requireAccessToken(accessToken);
+    const keyColumn = getPrimaryKeyColumn(table);
+    const resolvedId = preparedWrite.resolvedId ?? id;
+    const resolvedVersion = preparedWrite.resolvedVersion ?? version;
+    const { data, error } = await supabase
+        .from(table)
+        .update(preparedWrite.payload)
+        .eq(keyColumn, resolvedId)
+        .eq('version', resolvedVersion)
+        .select();
     if (error) {
-        console.error('Error invoking update_data function:', error);
+        console.error('Error updating the database:', error);
         throw error;
     }
-    const { data: updatedRows, error: functionError } = (functionPayload ??
-        {});
-    if (functionError) {
-        console.error('Supabase update_data returned an error:', functionError);
-        const message = functionError.message ?? 'Supabase update_data function rejected the request.';
-        throw new Error(message);
-    }
-    const keyColumn = getPrimaryKeyColumn(table);
-    const rows = ensureRows(updatedRows, `Update affected 0 rows for table "${table}"; verify the provided ${keyColumn} (${id}) and version (${version}) exist and are accessible.`);
-    return JSON.stringify({ id, version, data: rows });
+    const rows = ensureRows(data, `Update affected 0 rows for table "${table}"; verify the provided ${keyColumn} (${resolvedId}) and version (${resolvedVersion}) exist and are accessible.`);
+    return JSON.stringify({
+        id: resolvedId,
+        version: resolvedVersion,
+        data: sanitizeRowsForOutput(table, rows),
+    });
 }
 async function handleDelete(supabase, input) {
     const { table, id, version } = input;
@@ -307,7 +361,7 @@ async function handleDelete(supabase, input) {
         throw error;
     }
     const rows = ensureRows(data, `Delete affected 0 rows for table "${table}"; verify the provided ${keyColumn} (${id}) and version (${version}) exist and are accessible.`);
-    return JSON.stringify({ id, version, data: rows });
+    return JSON.stringify({ id, version, data: sanitizeRowsForOutput(table, rows) });
 }
 async function performCrud(input, bearerKey) {
     try {
@@ -316,9 +370,9 @@ async function performCrud(input, bearerKey) {
             case 'select':
                 return handleSelect(supabase, input);
             case 'insert':
-                return handleInsert(supabase, input);
+                return handleInsert(supabase, input, bearerKey);
             case 'update':
-                return handleUpdate(supabase, accessToken, input);
+                return handleUpdate(supabase, accessToken, input, bearerKey);
             case 'delete':
                 return handleDelete(supabase, input);
             default: {
@@ -333,7 +387,7 @@ async function performCrud(input, bearerKey) {
     }
 }
 export function regCrudTool(server, bearerKey) {
-    server.tool('Database_CRUD_Tool', 'Perform select/insert/update/delete against allowed Supabase tables (insert needs jsonOrdered, update/delete need id and version).', toolParamsSchema, async (rawInput) => {
+    server.tool('Database_CRUD_Tool', 'Perform select/insert/update/delete against allowed Supabase tables (insert needs jsonOrdered, update/delete need id and version). lifecyclemodels insert/update automatically validate the payload, derive platform json_tg, compute rule_verification, and then write the row; lifecyclemodels select returns id/version/json_ordered only.', toolParamsSchema, async (rawInput) => {
         const input = refinedInputSchema.parse(rawInput);
         const result = await performCrud(input, bearerKey);
         return {

package/dist/src/tools/glad_dataset_search.js

@@ -0,0 +1,332 @@
+import { z } from 'zod';
+import { glad_api_base_url, glad_api_key } from '../_shared/config.js';
+const sectorSchema = z.enum([
+    'Agriculture',
+    'Chemicals',
+    'Construction',
+    'Electronics',
+    'Energy',
+    'Food',
+    'Metals',
+    'Mining',
+    'Textiles',
+    'Transport',
+    'Other',
+]);
+const formatSchema = z.enum(['ECOSPOLD1', 'ECOSPOLD2', 'ILCD', 'JSON-LD', 'OTHER', 'UNKNOWN']);
+const processTypeSchema = z.enum([
+    'UNIT',
+    'PARTIALLY_AGGREGATED',
+    'FULLY_AGGREGATED',
+    'BRIDGE',
+    'UNKNOWN',
+]);
+const modelingTypeSchema = z.enum(['ATTRIBUTIONAL', 'CONSEQUENTIAL', 'BEFORE_MODELING', 'UNKNOWN']);
+const reviewTypeSchema = z.enum(['INTERNAL', 'EXTERNAL', 'PANEL', 'UNKNOWN', 'NONE']);
+const reviewSystemSchema = z.enum([
+    'ILCD',
+    'PEF',
+    'GHG',
+    'LCA_UN',
+    'OTHER',
+    'UNKNOWN',
+    'NOT_APPLICABLE',
+]);
+const extraFilterValueSchema = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.array(z.union([z.string(), z.number(), z.boolean()])),
+]);
+const gladSearchInputSchema = z.object({
+    query: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Full-text search query. GLAD searches name, description, category, and technology; multiple words are combined with AND.'),
+    page: z.number().int().min(0).default(0).describe('Zero-based GLAD result page. Default: 0.'),
+    pageSize: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .default(10)
+        .describe('Number of datasets to return. Capped at 100 to keep MCP responses usable.'),
+    sortBy: z.string().min(1).optional().describe('Field name to sort by, for example name.'),
+    sortOrder: z.enum(['ASC', 'DESC']).default('ASC').describe('Sort order used when sortBy is set.'),
+    sectors: z.array(sectorSchema).optional().describe('Filter by one or more GLAD sectors.'),
+    format: z.array(formatSchema).optional().describe('Filter by one or more dataset formats.'),
+    location: z
+        .array(z.string().min(1))
+        .optional()
+        .describe('Filter by one or more location codes, for example DE or ZA.'),
+    dataprovider: z
+        .array(z.string().min(1))
+        .optional()
+        .describe('Filter by one or more data provider names.'),
+    supportedNomenclatures: z
+        .array(z.string().min(1))
+        .optional()
+        .describe('Filter by supported nomenclature names, for example ecoinvent 3.5.'),
+    lciaMethods: z.array(z.string().min(1)).optional().describe('Filter by LCIA method names.'),
+    category: z
+        .array(z.string().min(1))
+        .optional()
+        .describe('Filter by category name or ISIC4 category code.'),
+    categoryPaths: z.array(z.string().min(1)).optional().describe('Filter by GLAD category paths.'),
+    unspscPaths: z.array(z.string().min(1)).optional().describe('Filter by UNSPSC path values.'),
+    co2pePaths: z.array(z.string().min(1)).optional().describe('Filter by CO2PE path values.'),
+    processType: z.array(processTypeSchema).optional().describe('Filter by GLAD process type.'),
+    modelingType: z.array(modelingTypeSchema).optional().describe('Filter by GLAD modeling type.'),
+    reviewType: z.array(reviewTypeSchema).optional().describe('Filter by GLAD review type.'),
+    reviewSystem: z.array(reviewSystemSchema).optional().describe('Filter by GLAD review system.'),
+    copyrightHolder: z.array(z.string().min(1)).optional().describe('Filter by copyright holder.'),
+    contact: z.string().min(1).optional().describe('Filter by contact value.'),
+    validFromYear: z.number().int().optional().describe('Filter by validity start year.'),
+    validUntilYear: z.number().int().optional().describe('Filter by validity end year.'),
+    copyrightProtected: z.boolean().optional().describe('Filter by copyright-protected status.'),
+    free: z.boolean().optional().describe('Filter by whether the dataset is available for free.'),
+    publiclyAccessible: z
+        .boolean()
+        .optional()
+        .describe('Filter by whether the dataset URL is publicly accessible without further login.'),
+    extraFilters: z
+        .record(z.string(), extraFilterValueSchema)
+        .optional()
+        .describe('Advanced GLAD query parameters not modeled explicitly. Use official parameter names; arrays are sent as repeated query parameters.'),
+});
+const gladGetDatasetInputSchema = z.object({
+    refId: z.string().min(1).describe('GLAD dataset refId.'),
+    dataProvider: z.string().min(1).describe('GLAD data provider name for the dataset.'),
+});
+const resultInfoSchema = z
+    .object({
+    currentPage: z.number().optional(),
+    pageSize: z.number().optional(),
+    pageCount: z.number().optional(),
+    count: z.number().optional(),
+    totalCount: z.number().optional(),
+})
+    .passthrough();
+const passthroughObjectSchema = z.object({}).passthrough();
+const gladSearchOutputSchema = z
+    .object({
+    request: z
+        .object({
+        endpoint: z.string(),
+        page: z.number(),
+        pageSize: z.number(),
+    })
+        .passthrough(),
+    resultInfo: resultInfoSchema.optional(),
+    data: z.array(passthroughObjectSchema),
+    aggregations: z.array(passthroughObjectSchema),
+})
+    .passthrough();
+const gladGetDatasetOutputSchema = z
+    .object({
+    request: z
+        .object({
+        endpoint: z.string(),
+        refId: z.string(),
+        dataProvider: z.string(),
+    })
+        .passthrough(),
+    dataSet: passthroughObjectSchema,
+})
+    .passthrough();
+const ARRAY_PARAM_MAP = {
+    'sectors[]': 'sectors',
+    'format[]': 'format',
+    'location[]': 'location',
+    'dataprovider[]': 'dataprovider',
+    'supportedNomenclatures[]': 'supportedNomenclatures',
+    'lciaMethods[]': 'lciaMethods',
+    'category[]': 'category',
+    'categoryPaths[]': 'categoryPaths',
+    'unspscPaths[]': 'unspscPaths',
+    'co2pePaths[]': 'co2pePaths',
+    'processType[]': 'processType',
+    'modelingType[]': 'modelingType',
+    'reviewType[]': 'reviewType',
+    'reviewSystem[]': 'reviewSystem',
+    'copyrightHolder[]': 'copyrightHolder',
+};
+const SCALAR_PARAM_NAMES = [
+    'query',
+    'sortBy',
+    'sortOrder',
+    'page',
+    'pageSize',
+    'contact',
+    'validFromYear',
+    'validUntilYear',
+    'copyrightProtected',
+    'free',
+    'publiclyAccessible',
+];
+function createGladUrl(pathname) {
+    const baseUrl = glad_api_base_url.replace(/\/+$/, '');
+    return new URL(`${baseUrl}${pathname}`);
+}
+function appendParam(params, key, value) {
+    if (value === undefined || value === null || value === '') {
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            appendParam(params, key, item);
+        }
+        return;
+    }
+    params.append(key, String(value));
+}
+function appendSearchParams(url, input) {
+    for (const key of SCALAR_PARAM_NAMES) {
+        appendParam(url.searchParams, key, input[key]);
+    }
+    for (const [wireName, inputKey] of Object.entries(ARRAY_PARAM_MAP)) {
+        appendParam(url.searchParams, wireName, input[inputKey]);
+    }
+    if (input.extraFilters) {
+        for (const [key, value] of Object.entries(input.extraFilters)) {
+            appendParam(url.searchParams, key, value);
+        }
+    }
+}
+function assertGladApiKey() {
+    if (!glad_api_key) {
+        throw new Error('Missing GLAD_API_KEY. Add it to the MCP server environment before using GLAD tools.');
+    }
+    return glad_api_key;
+}
+function buildGladErrorMessage(status, statusText, body) {
+    const trimmedBody = body.trim();
+    if (trimmedBody.startsWith('<!DOCTYPE html') || trimmedBody.startsWith('<html')) {
+        return `GLAD API returned an HTML page instead of JSON (HTTP ${status} ${statusText}). This usually means Cloudflare or browser verification blocked this Node.js runtime before the GLAD API processed the api-key. Verify this runtime can reach GLAD directly, or point GLAD_API_BASE_URL at an accessible GLAD-compatible API endpoint.`;
+    }
+    try {
+        const parsed = JSON.parse(trimmedBody);
+        if (typeof parsed === 'object' && parsed !== null && 'message' in parsed) {
+            return `GLAD API request failed (HTTP ${status} ${statusText}): ${String(parsed.message)}`;
+        }
+    }
+    catch {
+    }
+    const preview = trimmedBody.slice(0, 500);
+    return `GLAD API request failed (HTTP ${status} ${statusText})${preview ? `: ${preview}` : ''}`;
+}
+async function requestGladJson(url) {
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            Accept: 'application/json',
+            'User-Agent': 'TianGong-LCA-MCP/1.0',
+            'api-key': assertGladApiKey(),
+        },
+    });
+    const text = await response.text();
+    if (!response.ok) {
+        throw new Error(buildGladErrorMessage(response.status, response.statusText, text));
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new Error(`GLAD API returned a non-JSON success response from ${url.pathname}: ${error.message}`);
+    }
+}
+async function searchGladDatasets(input) {
+    const url = createGladUrl('/search');
+    appendSearchParams(url, input);
+    const result = await requestGladJson(url);
+    return {
+        request: {
+            endpoint: `${url.origin}${url.pathname}`,
+            page: input.page,
+            pageSize: input.pageSize,
+        },
+        resultInfo: result.resultInfo,
+        data: result.data ?? [],
+        aggregations: result.aggregations ?? [],
+    };
+}
+async function getGladDataset(input) {
+    const url = createGladUrl(`/search/index/${encodeURIComponent(input.refId)}/${encodeURIComponent(input.dataProvider)}`);
+    const dataSet = await requestGladJson(url);
+    return {
+        request: {
+            endpoint: `${url.origin}${url.pathname}`,
+            refId: input.refId,
+            dataProvider: input.dataProvider,
+        },
+        dataSet,
+    };
+}
+function toSuccessResult(output) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(output, null, 2),
+            },
+        ],
+        structuredContent: output,
+    };
+}
+function toErrorResult(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+        isError: true,
+        content: [
+            {
+                type: 'text',
+                text: message,
+            },
+        ],
+    };
+}
+export function regGladDatasetTools(server) {
+    server.registerTool('Search_GLAD_Datasets_Tool', {
+        title: 'Search GLAD Datasets',
+        description: 'Search Global LCA Data Access (GLAD) dataset descriptors through the official GLAD /search API. Requires GLAD_API_KEY in the MCP server environment.',
+        inputSchema: gladSearchInputSchema,
+        outputSchema: gladSearchOutputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (rawInput) => {
+        try {
+            const input = gladSearchInputSchema.parse(rawInput);
+            const output = await searchGladDatasets(input);
+            return toSuccessResult(output);
+        }
+        catch (error) {
+            return toErrorResult(error);
+        }
+    });
+    server.registerTool('Get_GLAD_Dataset_Tool', {
+        title: 'Get GLAD Dataset',
+        description: 'Fetch one GLAD dataset descriptor by refId and dataProvider through the official GLAD /search/index/{refId}/{dataProvider} API. Requires GLAD_API_KEY in the MCP server environment.',
+        inputSchema: gladGetDatasetInputSchema,
+        outputSchema: gladGetDatasetOutputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (rawInput) => {
+        try {
+            const input = gladGetDatasetInputSchema.parse(rawInput);
+            const output = await getGladDataset(input);
+            return toSuccessResult(output);
+        }
+        catch (error) {
+            return toErrorResult(error);
+        }
+    });
+}