@tiangong-lca/mcp-server 0.0.20 → 0.0.22

package/dist/src/_shared/init_server.js

@@ -1,13 +1,12 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { regOpenLcaPrompts } from '../prompts/lca_calculation.js';
 import { regOpenLcaResources } from '../resources/lca_calculation.js';
-import { regBomCalculationTool } from '../tools/bom_calculation.js';
 import { regFlowSearchTool } from '../tools/flow_hybrid_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';
 import { regOpenLcaListLCIAMethodsTool } from '../tools/openlca_ipc_lcia_methods_list.js';
-import { regOpenLcaListProductSystemsTool } from '../tools/openlca_ipc_process_list.js';
+import { regOpenLcaListSystemProcessesTool } from '../tools/openlca_ipc_system_processes_list.js';
 import { regProcessSearchTool } from '../tools/process_hybrid_search.js';
 export function initializeServer(bearerKey) {
     const server = new McpServer({
@@ -17,9 +16,8 @@ export function initializeServer(bearerKey) {
     regFlowSearchTool(server, bearerKey);
     regProcessSearchTool(server, bearerKey);
     regLifecycleModelSearchTool(server, bearerKey);
-    regBomCalculationTool(server);
     regOpenLcaLciaTool(server);
-    regOpenLcaListProductSystemsTool(server);
+    regOpenLcaListSystemProcessesTool(server);
     regOpenLcaListLCIAMethodsTool(server);
     regOpenLcaPrompts(server);
     regOpenLcaResources(server);

package/dist/src/_shared/init_server_http.js

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

package/dist/src/_shared/init_server_http_local.js

@@ -3,7 +3,8 @@ import { regOpenLcaPrompts } from '../prompts/lca_calculation.js';
 import { regOpenLcaResources } from '../resources/lca_calculation.js';
 import { regOpenLcaLciaTool } from '../tools/openlca_ipc_lcia.js';
 import { regOpenLcaListLCIAMethodsTool } from '../tools/openlca_ipc_lcia_methods_list.js';
-import { regOpenLcaListProductSystemsTool } from '../tools/openlca_ipc_process_list.js';
+import { regOpenLcaListSystemProcessesTool } from '../tools/openlca_ipc_system_processes_list.js';
+import { regTidasValidationTool } from '../tools/tidas_data_validation.js';
 export function initializeServer() {
     const server = new McpServer({
         name: 'TianGong-LCA-MCP-Server',
@@ -11,7 +12,8 @@ export function initializeServer() {
     });
     regOpenLcaLciaTool(server);
     regOpenLcaListLCIAMethodsTool(server);
-    regOpenLcaListProductSystemsTool(server);
+    regOpenLcaListSystemProcessesTool(server);
+    regTidasValidationTool(server);
     regOpenLcaPrompts(server);
     regOpenLcaResources(server);
     return server;

package/dist/src/prompts/lca_calculation.js

@@ -9,7 +9,7 @@ export function regOpenLcaPrompts(server) {
                         text: `I am an expert in Life Cycle Assessment (LCA) and use the MCP tool to perform LCA calculations. 
             The workflow is as follows:
             1. Use the OpenLCA_Impact_Assessment_Tool to list all LCIA (Life Cycle Impact Assessment) method UUIDs and their corresponding names.
-            2. Use the OpenLCA_List_Product_Systems_Tool to list all product system UUIDs and their corresponding names.
+            2. Use the OpenLCA_List_System_Processes_Tool to list all system process UUIDs and their corresponding names.
             3. Use the OpenLCA_Impact_Assessment_Tool to perform LCA calculations.`,
                     },
                 },

package/dist/src/resources/lca_calculation.js

@@ -7,7 +7,7 @@ export function regOpenLcaResources(server) {
                     mimeType: 'text/plain',
                     text: `The workflow to perform LCA calculations using the MCP tool is as follows:
             1. Use the OpenLCA_Impact_Assessment_Tool to list all LCIA (Life Cycle Impact Assessment) method UUIDs and their corresponding names.
-            2. Use the OpenLCA_List_Product_Systems_Tool to list all product system UUIDs and their corresponding names.
+            2. Use the OpenLCA_List_System_Processes_Tool to list all system process UUIDs and their corresponding names.
             3. Use the OpenLCA_Impact_Assessment_Tool to perform LCA calculations.`,
                 },
             ],

package/dist/src/tools/flow_hybrid_search.js

@@ -30,7 +30,7 @@ async function searchFlows({ query }, bearerKey) {
     }
 }
 export function regFlowSearchTool(server, bearerKey) {
-    server.tool('Search_flows_Tool', 'Search LCA flows data.', input_schema, async ({ query }) => {
+    server.tool('Search_Flows_Tool', 'Search LCA flows data.', input_schema, async ({ query }) => {
         const result = await searchFlows({
             query,
         }, bearerKey);

package/dist/src/tools/lca_calculation_guidance.js

@@ -1,7 +1,7 @@
 async function getLcaCalculationGuidance() {
     const prompt = `The workflow to perform LCA calculations using the MCP tool is as follows:
             1. Use the OpenLCA_Impact_Assessment_Tool to list all LCIA (Life Cycle Impact Assessment) method UUIDs and their corresponding names.
-            2. Use the OpenLCA_List_Product_Systems_Tool to list all product system UUIDs and their corresponding names.
+            2. Use the OpenLCA_List_System_Processes_Tool to list all system process UUIDs and their corresponding names.
             3. Use the OpenLCA_Impact_Assessment_Tool to perform LCA calculations.`;
     return prompt;
 }

package/dist/src/tools/life_cycle_model_hybrid_search.js

@@ -30,7 +30,7 @@ async function searchLifecycleModels({ query }, bearerKey) {
     }
 }
 export function regLifecycleModelSearchTool(server, bearerKey) {
-    server.tool('Search_life_cycle_models_Tool', 'Search LCA life cycle models data.', input_schema, async ({ query }) => {
+    server.tool('Search_Life_Cycle_Models_Tool', 'Search LCA life cycle models data.', input_schema, async ({ query }) => {
         const result = await searchLifecycleModels({
             query,
         }, bearerKey);

package/dist/src/tools/{openlca_ipc_process_list.js → openlca_ipc_system_processes_list.js}

@@ -3,13 +3,14 @@ import { z } from 'zod';
 const input_schema = {
     serverUrl: z.string().default('http://localhost:8080').describe('OpenLCA IPC server URL'),
 };
-async function listProductSystems({ serverUrl = 'http://localhost:8080', }) {
+async function listSystemProcesses({ serverUrl = 'http://localhost:8080', }) {
     const client = o.IpcClient.on(serverUrl);
-    const productSystems = await client.getDescriptors(o.RefType.ProductSystem);
-    if (productSystems.length === 0) {
-        throw new Error('No product systems found');
+    const processes = await client.getDescriptors(o.RefType.Process);
+    const systemProcesses = processes.filter((proc) => proc.processType === o.ProcessType.LCI_RESULT);
+    if (systemProcesses.length === 0) {
+        throw new Error('No system processes found');
     }
-    const resultsObj = productSystems.map((sys) => {
+    const resultsObj = systemProcesses.map((sys) => {
         const result = {
             id: sys.id,
             category: sys.category,
@@ -30,9 +31,9 @@ async function listProductSystems({ serverUrl = 'http://localhost:8080', }) {
     });
     return JSON.stringify(resultsObj);
 }
-export function regOpenLcaListProductSystemsTool(server) {
-    server.tool('OpenLCA_List_Product_Systems_Tool', 'List all product systems using OpenLCA.', input_schema, async ({ serverUrl }) => {
-        const result = await listProductSystems({
+export function regOpenLcaListSystemProcessesTool(server) {
+    server.tool('OpenLCA_List_System_Processes_Tool', 'List all system processes using OpenLCA.', input_schema, async ({ serverUrl }) => {
+        const result = await listSystemProcesses({
             serverUrl: serverUrl,
         });
         return {

package/dist/src/tools/process_hybrid_search.js

@@ -30,7 +30,7 @@ async function searchProcesses({ query }, bearerKey) {
     }
 }
 export function regProcessSearchTool(server, bearerKey) {
-    server.tool('Search_processes_Tool', 'Search LCA processes data.', input_schema, async ({ query }) => {
+    server.tool('Search_Processes_Tool', 'Search LCA processes data.', input_schema, async ({ query }) => {
         const result = await searchProcesses({
             query,
         }, bearerKey);

package/dist/src/tools/tidas_data_validation.js

@@ -0,0 +1,207 @@
+import { createContact, createFlow, createFlowProperty, createLCIAMethod, createLifeCycleModel, createProcess, createSource, createUnitGroup, } from '@tiangong-lca/tidas-sdk/core';
+import { z } from 'zod';
+const ENTITY_TYPES = [
+    'contact',
+    'flow',
+    'process',
+    'source',
+    'flowProperty',
+    'unitGroup',
+    'lciaMethod',
+    'lifeCycleModel',
+];
+const ENTITY_METADATA = {
+    contact: {
+        name: 'Contact',
+        description: 'Contact information data',
+    },
+    flow: {
+        name: 'Flow',
+        description: 'Flow data (material/energy flows)',
+    },
+    process: {
+        name: 'Process',
+        description: 'Process data',
+    },
+    source: {
+        name: 'Source',
+        description: 'Data source information',
+    },
+    flowProperty: {
+        name: 'FlowProperty',
+        description: 'Flow property data',
+    },
+    unitGroup: {
+        name: 'UnitGroup',
+        description: 'Unit group data',
+    },
+    lciaMethod: {
+        name: 'LCIAMethod',
+        description: 'Life Cycle Impact Assessment method data',
+    },
+    lifeCycleModel: {
+        name: 'LifeCycleModel',
+        description: 'Life cycle model data',
+    },
+};
+const jsonValueSchema = z.lazy(() => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(jsonValueSchema),
+    z.record(jsonValueSchema),
+]));
+function validateTidasData(entityType, data) {
+    try {
+        let validationResult;
+        switch (entityType) {
+            case 'contact': {
+                const entity = createContact(data, { mode: 'strict' });
+                validationResult = entity.validate();
+                break;
+            }
+            case 'flow': {
+                const entity = createFlow(data, { mode: 'strict' });
+                validationResult = entity.validate();
+                break;
+            }
+            case 'process': {
+                const entity = createProcess(data, { mode: 'strict' });
+                validationResult = entity.validate();
+                break;
+            }
+            case 'source': {
+                const entity = createSource(data, { mode: 'strict' });
+                validationResult = entity.validate();
+                break;
+            }
+            case 'flowProperty': {
+                const entity = createFlowProperty(data, { mode: 'strict' });
+                validationResult = entity.validate();
+                break;
+            }
+            case 'unitGroup': {
+                const entity = createUnitGroup(data, { mode: 'strict' });
+                validationResult = entity.validate();
+                break;
+            }
+            case 'lciaMethod': {
+                const entity = createLCIAMethod(data, { mode: 'strict' });
+                validationResult = entity.validate();
+                break;
+            }
+            case 'lifeCycleModel': {
+                const entity = createLifeCycleModel(data, { mode: 'strict' });
+                validationResult = entity.validate();
+                break;
+            }
+            default: {
+                const exhaustiveCheck = entityType;
+                throw new Error(`Unsupported entity type: ${entityType}`);
+            }
+        }
+        if (validationResult.success) {
+            return {
+                success: true,
+                message: `✓ Validation passed for ${ENTITY_METADATA[entityType].name}`,
+            };
+        }
+        else {
+            const errorDetails = validationResult.error?.issues
+                ? JSON.stringify(validationResult.error.issues, null, 2)
+                : JSON.stringify(validationResult.error);
+            return {
+                success: false,
+                error: validationResult.error,
+                message: `✗ Validation failed for ${ENTITY_METADATA[entityType].name}`,
+            };
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return {
+                success: false,
+                error: error,
+                message: `✗ Error validating ${ENTITY_METADATA[entityType].name}: ${error.message}`,
+            };
+        }
+        return {
+            success: false,
+            error: error,
+            message: `✗ Unknown error occurred during validation`,
+        };
+    }
+}
+export function regTidasValidationTool(server) {
+    const entityTypeList = ENTITY_TYPES.map((type) => `  - ${type}: ${ENTITY_METADATA[type].name} - ${ENTITY_METADATA[type].description}`).join('\n');
+    server.tool('Tidas_Data_Validate_Tool', `Validate LCA data against Tidas SDK schemas.
+
+Supported entity types (8 types):
+${entityTypeList}
+
+This tool validates data structure and required fields according to ILCD/TIDAS standards.
+Use strict validation mode to ensure data integrity before database operations.`, {
+        entityType: z
+            .enum(ENTITY_TYPES)
+            .describe(`Type of entity to validate. Must be one of: ${ENTITY_TYPES.join(', ')}. Each type corresponds to a specific LCA data structure.`),
+        data: jsonValueSchema.describe('The JSON data to validate. Should be a complete entity object matching the specified entityType structure according to ILCD/TIDAS format.'),
+    }, async ({ entityType, data }) => {
+        try {
+            const result = validateTidasData(entityType, data);
+            if (result.success) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `${result.message}
+
+Entity Type: ${ENTITY_METADATA[entityType].name}
+Status: ✓ Valid
+Description: ${ENTITY_METADATA[entityType].description}
+
+The data conforms to the ${ENTITY_METADATA[entityType].name} schema and can be safely used for database operations.`,
+                        },
+                    ],
+                };
+            }
+            else {
+                const errorDetails = result.error?.issues
+                    ? JSON.stringify(result.error.issues, null, 2)
+                    : result.error
+                        ? JSON.stringify(result.error, null, 2)
+                        : 'Unknown validation error';
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `${result.message}
+
+Entity Type: ${ENTITY_METADATA[entityType].name}
+Status: ✗ Invalid
+Description: ${ENTITY_METADATA[entityType].description}
+
+Validation Errors:
+${errorDetails}
+
+Please fix the validation errors before attempting database operations.`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to validate data: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiangong-lca/mcp-server",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "TianGong LCA MCP Server",
   "license": "MIT",
   "author": "Nan LI",
@@ -22,6 +22,7 @@
     "start": "npm run build && npx dotenv -e .env -- npx @modelcontextprotocol/inspector node dist/src/index.js",
     "start:server": "npm run build && concurrently \"npx dotenv -e .env -- node dist/src/index_server.js\" \"DANGEROUSLY_OMIT_AUTH=true npx @modelcontextprotocol/inspector\"",
     "start:server-local": "npm run build && concurrently \"npx dotenv -e .env -- node dist/src/index_server_local.js\" \"DANGEROUSLY_OMIT_AUTH=true npx @modelcontextprotocol/inspector\"",
+    "test": "node test/tidas_validation_test.js",
     "lint": "prettier -c --write \"**/**.{js,jsx,tsx,ts,less,md,json}\"",
     "ncu": "npx npm-check-updates",
     "ncu:update": "npx npm-check-updates -u"

package/dist/src/tools/bom_calculation.js

@@ -1,30 +0,0 @@
-import { z } from 'zod';
-const input_schema = {
-    a: z.number().min(1).describe('The first number'),
-    b: z.number().min(1).describe('The second number'),
-};
-async function calculation({ a, b }) {
-    try {
-        return a + b;
-    }
-    catch (error) {
-        console.error('Error making the request:', error);
-        throw error;
-    }
-}
-export function regBomCalculationTool(server) {
-    server.tool('BOM_Calculation', 'Calculate sum of two numbers.', input_schema, async ({ a, b }) => {
-        const result = await calculation({
-            a,
-            b,
-        });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: result.toString(),
-                },
-            ],
-        };
-    });
-}