vme-mcp-server 0.1.5 → 0.1.6

package/dist/server_old.js

@@ -0,0 +1,933 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const axios_1 = __importDefault(require("axios"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+dotenv_1.default.config();
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+// AI Training Data Collection Configuration
+const AI_TRAINING_ENABLED = process.env.ENABLE_AI_TRAINING_DATA === 'true';
+const AI_TRAINING_FIELDS = (process.env.AI_TRAINING_DATA_FIELDS || 'user_input,parsed_output,success_metrics').split(',');
+const AI_TRAINING_RETENTION_DAYS = parseInt(process.env.AI_TRAINING_DATA_RETENTION_DAYS || '30');
+// Privacy-aware interaction logging
+function logInteraction(interaction) {
+    if (!AI_TRAINING_ENABLED) {
+        return; // Respect user privacy choice
+    }
+    try {
+        // Ensure logs directory exists
+        const logsDir = (0, path_1.join)(process.cwd(), 'ai-training-logs');
+        if (!(0, fs_1.existsSync)(logsDir)) {
+            (0, fs_1.mkdirSync)(logsDir, { recursive: true });
+        }
+        // Filter fields based on user preferences
+        const filteredInteraction = {
+            id: interaction.id || `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            timestamp: new Date().toISOString(),
+            session_id: interaction.session_id || 'unknown',
+            tool_name: interaction.tool_name || 'unknown'
+        };
+        // Only include fields user has opted into
+        if (AI_TRAINING_FIELDS.includes('user_input') && interaction.user_input) {
+            filteredInteraction.user_input = interaction.user_input;
+        }
+        if (AI_TRAINING_FIELDS.includes('parsed_output') && interaction.parsed_output) {
+            filteredInteraction.parsed_output = interaction.parsed_output;
+        }
+        if (AI_TRAINING_FIELDS.includes('api_calls') && interaction.api_calls) {
+            filteredInteraction.api_calls = interaction.api_calls;
+        }
+        if (AI_TRAINING_FIELDS.includes('success_metrics') && interaction.success_metrics) {
+            filteredInteraction.success_metrics = interaction.success_metrics;
+        }
+        if (AI_TRAINING_FIELDS.includes('timing') && interaction.timing) {
+            filteredInteraction.timing = interaction.timing;
+        }
+        // Append to daily log file (JSONL format)
+        const logFile = (0, path_1.join)(logsDir, `interactions-${new Date().toISOString().split('T')[0]}.jsonl`);
+        const logEntry = JSON.stringify(filteredInteraction) + '\n';
+        (0, fs_1.writeFileSync)(logFile, logEntry, { flag: 'a' });
+    }
+    catch (error) {
+        // Fail silently to not disrupt user experience
+        console.warn('AI training data logging failed:', error);
+    }
+}
+// Generate session ID for interaction tracking
+function generateSessionId() {
+    return `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+const api = axios_1.default.create({
+    baseURL: process.env.VME_API_BASE_URL,
+    headers: {
+        Authorization: `Bearer ${process.env.VME_API_TOKEN}`,
+        "Content-Type": "application/json"
+    }
+});
+// Helper function to parse VM name patterns
+function parseVMNames(nameInput, count) {
+    // Handle range patterns like "web01->web03" or "web01 -> web03"
+    const rangeMatch = nameInput.match(/^(.+?)(\d+)\s*->\s*(.+?)(\d+)$/);
+    if (rangeMatch) {
+        const [, prefix1, start, prefix2, end] = rangeMatch;
+        if (prefix1.trim() === prefix2.trim()) {
+            const basePrefix = prefix1.trim();
+            const startNum = parseInt(start);
+            const endNum = parseInt(end);
+            const names = [];
+            for (let i = startNum; i <= endNum; i++) {
+                const paddedNum = i.toString().padStart(start.length, '0');
+                names.push(`${basePrefix}${paddedNum}`);
+            }
+            return names;
+        }
+    }
+    // Handle count-based generation
+    if (count && count > 1) {
+        const names = [];
+        // Extract base name and number pattern
+        const match = nameInput.match(/^(.+?)(\d+)$/);
+        if (match) {
+            const [, prefix, startStr] = match;
+            const startNum = parseInt(startStr);
+            for (let i = 0; i < count; i++) {
+                const num = startNum + i;
+                const paddedNum = num.toString().padStart(startStr.length, '0');
+                names.push(`${prefix}${paddedNum}`);
+            }
+            return names;
+        }
+        else {
+            // If no number pattern, append numbers
+            for (let i = 1; i <= count; i++) {
+                const paddedNum = i.toString().padStart(2, '0');
+                names.push(`${nameInput}${paddedNum}`);
+            }
+            return names;
+        }
+    }
+    // Single VM
+    return [nameInput];
+}
+// Helper function to get available cluster nodes
+async function getClusterNodes() {
+    try {
+        const clusters = await api.get("/clusters");
+        const prodCluster = clusters.data.clusters.find((cluster) => cluster.name === "prod01");
+        if (prodCluster && prodCluster.servers) {
+            return prodCluster.servers.map((server) => server.id);
+        }
+    }
+    catch (error) {
+        console.error('Error getting cluster nodes:', error);
+    }
+    // Fallback to known nodes if API fails
+    return [1, 2, 3];
+}
+async function resolveInput({ group, cloud, template, size }) {
+    const [groups, zones, instanceTypes, servicePlans] = await Promise.all([
+        api.get("/groups"),
+        api.get("/zones"),
+        api.get("/instance-types"),
+        api.get("/service-plans")
+    ]);
+    // Find group (case-insensitive)
+    const foundGroup = groups.data.groups.find((g) => g.name.toLowerCase() === group.toLowerCase());
+    // Find zone/cloud (case-insensitive, handle both terms)
+    const foundZone = zones.data.zones.find((z) => z.name.toLowerCase() === cloud.toLowerCase());
+    // In HPE VM Essentials, all VMs use "HPE VM" instance type
+    // The actual OS is determined by the image selection
+    const instanceType = instanceTypes.data.instanceTypes.find((t) => t.name === 'HPE VM');
+    // Find appropriate image based on template using osType properties
+    let selectedImage;
+    const templateLower = template.toLowerCase();
+    // Get available images to find the right one
+    const images = await api.get("/virtual-images");
+    if (templateLower.includes('ubuntu')) {
+        // Find Ubuntu images using osType.category and prefer latest version
+        const ubuntuImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'ubuntu').sort((a, b) => {
+            // Sort by version descending (24.04 > 22.04 > 20.04)
+            const aVersion = parseFloat(a.osType.osVersion || '0');
+            const bVersion = parseFloat(b.osType.osVersion || '0');
+            return bVersion - aVersion;
+        });
+        selectedImage = ubuntuImages[0];
+    }
+    else if (templateLower.includes('rocky')) {
+        // Find Rocky Linux images and prefer latest version (Rocky 9 > Rocky 8)
+        const rockyImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'rocky').sort((a, b) => {
+            const aVersion = parseInt(a.osType.osVersion || '0');
+            const bVersion = parseInt(b.osType.osVersion || '0');
+            return bVersion - aVersion; // Latest first
+        });
+        selectedImage = rockyImages[0];
+    }
+    else if (templateLower.includes('centos')) {
+        // Find CentOS images and prefer latest version (CentOS 9 > CentOS 8)
+        const centosImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'centos').sort((a, b) => {
+            const aVersion = parseInt(a.osType.osVersion || '0');
+            const bVersion = parseInt(b.osType.osVersion || '0');
+            return bVersion - aVersion; // Latest first
+        });
+        selectedImage = centosImages[0];
+    }
+    else if (templateLower.includes('debian')) {
+        // Find Debian images and prefer latest version (Debian 12 > Debian 11)
+        const debianImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'debian').sort((a, b) => {
+            const aVersion = parseInt(a.osType.osVersion || '0');
+            const bVersion = parseInt(b.osType.osVersion || '0');
+            return bVersion - aVersion; // Latest first
+        });
+        selectedImage = debianImages[0];
+    }
+    else if (templateLower.includes('alma')) {
+        // Find AlmaLinux images and prefer latest version (AlmaLinux 9 > AlmaLinux 8)
+        const almaImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'almalinux').sort((a, b) => {
+            const aVersion = parseInt(a.osType.osVersion || '0');
+            const bVersion = parseInt(b.osType.osVersion || '0');
+            return bVersion - aVersion; // Latest first
+        });
+        selectedImage = almaImages[0];
+    }
+    else if (templateLower.includes('rhel') || templateLower.includes('red hat')) {
+        // Find RHEL images and prefer latest version
+        const rhelImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'rhel').sort((a, b) => {
+            const aVersion = parseInt(a.osType.osVersion || '0');
+            const bVersion = parseInt(b.osType.osVersion || '0');
+            return bVersion - aVersion; // Latest first
+        });
+        selectedImage = rhelImages[0];
+    }
+    // Default to latest Ubuntu if no specific match
+    if (!selectedImage) {
+        const ubuntuImages = images.data.virtualImages.filter((img) => img.osType && img.osType.category === 'ubuntu').sort((a, b) => {
+            const aVersion = parseFloat(a.osType.osVersion || '0');
+            const bVersion = parseFloat(b.osType.osVersion || '0');
+            return bVersion - aVersion;
+        });
+        selectedImage = ubuntuImages[0] || images.data.virtualImages[0];
+    }
+    // Find service plan based on size (flexible matching)
+    let plan;
+    const sizeLower = size.toLowerCase();
+    if (sizeLower.includes('8gb') || sizeLower.includes('8 gb') || sizeLower.includes('medium')) {
+        plan = servicePlans.data.servicePlans.find((p) => p.name.includes('2 CPU, 8GB Memory'));
+    }
+    else if (sizeLower.includes('4gb') || sizeLower.includes('4 gb') || sizeLower.includes('small')) {
+        plan = servicePlans.data.servicePlans.find((p) => p.name.includes('1 CPU, 4GB Memory'));
+    }
+    // Fallback to any available plan
+    if (!plan) {
+        plan = servicePlans.data.servicePlans.find((p) => p.name.includes('CPU') && p.name.includes('Memory'));
+    }
+    return {
+        groupId: foundGroup?.id || groups.data.groups[0]?.id,
+        cloudId: foundZone?.id || zones.data.zones[0]?.id,
+        instanceTypeId: instanceType?.id,
+        servicePlanId: plan?.id,
+        imageId: selectedImage?.id,
+        // Return resolved names for better error reporting
+        resolvedGroup: foundGroup?.name || groups.data.groups[0]?.name,
+        resolvedCloud: foundZone?.name || zones.data.zones[0]?.name,
+        resolvedInstanceType: instanceType?.name,
+        resolvedPlan: plan?.name,
+        resolvedImage: selectedImage?.osType?.name || selectedImage?.name,
+        // Available options for error messages
+        availableGroups: groups.data.groups.map((g) => g.name),
+        availableZones: zones.data.zones.map((z) => z.name)
+    };
+}
+function parseVMIntent(naturalLanguageInput) {
+    const input = naturalLanguageInput.toLowerCase().trim();
+    const result = {
+        action: 'unknown',
+        confidence: 0,
+        entities: {},
+        originalText: naturalLanguageInput
+    };
+    // Intent Classification with confidence scoring
+    const intentPatterns = {
+        create: [
+            /\b(create|provision|deploy|launch|start|build|make|setup)\b/,
+            /\bneed\s+(\d+\s+)?(vm|server|machine)/,
+            /\bcan\s+you\s+(create|provision|deploy)/
+        ],
+        modify: [
+            /\b(modify|change|update|edit|alter|resize|scale)\b/,
+            /\badd\s+(more\s+)?(cpu|memory|disk|storage)/,
+            /\bchange\s+the\s+(size|plan|configuration)/
+        ],
+        monitor: [
+            /\b(show|list|display|check|status|monitor|view)\b(?!.*\b(available|options|resources|templates|plans)\b)/,
+            /\bwhat\s+(vm|server|machine)/,
+            /\bhow\s+many\s+(vm|server|machine)/
+        ],
+        destroy: [
+            /\b(delete|remove|destroy|terminate|stop|kill)\b/,
+            /\btear\s+down/,
+            /\bshut\s+down/
+        ],
+        discover: [
+            /\b(available|options|resources|templates|plans)\b/,
+            /\bshow\s+me\s+(all|available)/,
+            /\bwhat\s+(are|is)\s+(available|possible)/,
+            /\bwhat\s+can\s+i\s+(create|do)/
+        ]
+    };
+    // Calculate confidence for each intent
+    let maxConfidence = 0;
+    let detectedAction = 'unknown';
+    for (const [action, patterns] of Object.entries(intentPatterns)) {
+        let matches = 0;
+        for (const pattern of patterns) {
+            if (pattern.test(input)) {
+                matches++;
+            }
+        }
+        const confidence = patterns.length > 0 ? matches / patterns.length : 0;
+        if (confidence > maxConfidence) {
+            maxConfidence = confidence;
+            detectedAction = action;
+        }
+    }
+    result.action = detectedAction;
+    result.confidence = maxConfidence;
+    // Entity Extraction for VM creation
+    if (result.action === 'create') {
+        // Extract VM names and count
+        const namePatterns = [
+            /\b(?:vm|server|machine)s?\s+(?:named\s+)?["']?([a-zA-Z0-9\-_]+(?:\s*->\s*[a-zA-Z0-9\-_]+)?)["']?/,
+            /\b(?:named\s+)?["']?([a-zA-Z0-9\-_]+(?:\s*->\s*[a-zA-Z0-9\-_]+)?)["']?\s+(?:vm|server|machine)/,
+            /\bcreate\s+(?:(?:vm|server|machine)s?\s+)?["']?([a-zA-Z0-9\-_]+(?:\s*->\s*[a-zA-Z0-9\-_]+)?)["']?/,
+            /\b(?:vm|server|machine)\s+named\s+["']?([a-zA-Z0-9\-_]+(?:\s*->\s*[a-zA-Z0-9\-_]+)?)["']?/
+        ];
+        for (const pattern of namePatterns) {
+            const match = input.match(pattern);
+            if (match) {
+                const nameInput = match[1] || match[2];
+                result.entities.vmNames = parseVMNames(nameInput);
+                break;
+            }
+        }
+        // Extract count
+        const countMatch = input.match(/\b(\d+)\s+(?:vm|server|machine)/);
+        if (countMatch) {
+            result.entities.count = parseInt(countMatch[1]);
+        }
+        // Extract OS template
+        const osPatterns = [
+            /\b(ubuntu|rocky|centos|debian|rhel|red\s*hat|alma|almalinux)(?:\s+(\d+(?:\.\d+)?))?/,
+            /\busing\s+([a-zA-Z0-9\-_]+)\s+(?:template|os|operating)/,
+            /\b(?:template|os|operating)\s+([a-zA-Z0-9\-_]+)/
+        ];
+        for (const pattern of osPatterns) {
+            const match = input.match(pattern);
+            if (match) {
+                result.entities.osTemplate = match[0];
+                break;
+            }
+        }
+        // Extract size/memory
+        const sizePatterns = [
+            /\b(small|medium|large|tiny)\b/,
+            /\b(\d+)\s*gb\s+(?:memory|ram)\b/,
+            /\b(\d+)\s*cpu[s]?\s*,?\s*(\d+)\s*gb/,
+            /\bwith\s+(\d+(?:gb|cpu))\b/,
+            /\b(\d+gb)\b/
+        ];
+        for (const pattern of sizePatterns) {
+            const match = input.match(pattern);
+            if (match) {
+                result.entities.size = match[0];
+                break;
+            }
+        }
+        // Extract group/environment
+        const groupPatterns = [
+            /\bin\s+(?:the\s+)?([a-zA-Z0-9\-_]+)\s+(?:group|environment|site)/,
+            /\b(?:group|environment|site)\s+([a-zA-Z0-9\-_]+)/,
+            /\bfor\s+([a-zA-Z0-9\-_]+)\s+(?:environment|testing|production)/
+        ];
+        for (const pattern of groupPatterns) {
+            const match = input.match(pattern);
+            if (match) {
+                result.entities.group = match[1];
+                break;
+            }
+        }
+        // Extract zone/cloud
+        const zonePatterns = [
+            /\bon\s+([a-zA-Z0-9\-_]+)\s+(?:zone|cloud)/,
+            /\b(?:zone|cloud)\s+([a-zA-Z0-9\-_]+)/,
+            /\bin\s+([a-zA-Z0-9\-_]+)\s+(?:zone|cloud)/,
+            /\b(?:deploy|launch|create)\s+(?:in\s+)?([a-zA-Z0-9\-_]+)\s+zone/
+        ];
+        for (const pattern of zonePatterns) {
+            const match = input.match(pattern);
+            if (match) {
+                result.entities.zone = match[1];
+                break;
+            }
+        }
+        // Extract distribution strategy
+        if (input.includes('spread') || input.includes('distribute') || input.includes('across')) {
+            result.entities.distribution = 'spread';
+        }
+        else if (input.includes('each node') || input.includes('all nodes')) {
+            result.entities.distribution = 'spread';
+        }
+        else if (input.includes('node') && input.match(/node[s]?\s*[\d,\s]+/)) {
+            const nodeMatch = input.match(/node[s]?\s*([\d,\s]+)/);
+            if (nodeMatch) {
+                result.entities.distribution = nodeMatch[1].replace(/\s+/g, '');
+            }
+        }
+        // Boost confidence if we extracted entities
+        const entityCount = Object.keys(result.entities).length;
+        if (entityCount > 0) {
+            result.confidence = Math.min(0.95, result.confidence + (entityCount * 0.1));
+        }
+    }
+    return result;
+}
+// Unified resource discovery function
+async function getResources(type, intent, role) {
+    try {
+        // Fetch all resource types in parallel for comprehensive discovery
+        const [groups, zones, instanceTypes, servicePlans, virtualImages, clusters] = await Promise.all([
+            api.get("/groups"),
+            api.get("/zones"),
+            api.get("/instance-types"),
+            api.get("/service-plans"),
+            api.get("/virtual-images"),
+            api.get("/clusters")
+        ]);
+        const allResources = {
+            groups: groups.data.groups || [],
+            zones: zones.data.zones || [],
+            instanceTypes: instanceTypes.data.instanceTypes || [],
+            servicePlans: servicePlans.data.servicePlans || [],
+            virtualImages: virtualImages.data.virtualImages || [],
+            clusters: clusters.data.clusters || []
+        };
+        // Apply intelligent filtering based on type
+        if (type) {
+            const typeLower = type.toLowerCase();
+            if (typeLower.includes('compute') || typeLower.includes('vm')) {
+                return {
+                    groups: allResources.groups,
+                    zones: allResources.zones,
+                    servicePlans: allResources.servicePlans,
+                    virtualImages: allResources.virtualImages,
+                    clusters: allResources.clusters,
+                    _filtered_for: 'compute/vm resources'
+                };
+            }
+            else if (typeLower.includes('network')) {
+                return {
+                    zones: allResources.zones,
+                    clusters: allResources.clusters,
+                    _filtered_for: 'network resources'
+                };
+            }
+            else if (typeLower.includes('storage')) {
+                return {
+                    servicePlans: allResources.servicePlans,
+                    zones: allResources.zones,
+                    _filtered_for: 'storage resources'
+                };
+            }
+        }
+        // Apply intent-based filtering
+        if (intent) {
+            const intentLower = intent.toLowerCase();
+            if (intentLower.includes('create') || intentLower.includes('provision')) {
+                // For creation intents, focus on templates and plans
+                return {
+                    groups: allResources.groups,
+                    zones: allResources.zones,
+                    servicePlans: allResources.servicePlans,
+                    virtualImages: allResources.virtualImages.map((img) => ({
+                        id: img.id,
+                        name: img.name,
+                        osType: img.osType,
+                        recommended: img.osType?.category === 'ubuntu' ? true : false
+                    })),
+                    _filtered_for: 'creation/provisioning intent'
+                };
+            }
+            else if (intentLower.includes('list') || intentLower.includes('show') || intentLower.includes('discover')) {
+                // For discovery intents, return comprehensive view
+                return {
+                    summary: {
+                        total_groups: allResources.groups.length,
+                        total_zones: allResources.zones.length,
+                        total_service_plans: allResources.servicePlans.length,
+                        total_os_templates: allResources.virtualImages.length,
+                        total_clusters: allResources.clusters.length
+                    },
+                    ...allResources,
+                    _filtered_for: 'discovery/listing intent'
+                };
+            }
+        }
+        // Default: return all resources with semantic organization
+        return {
+            compute: {
+                groups: allResources.groups,
+                servicePlans: allResources.servicePlans,
+                virtualImages: allResources.virtualImages
+            },
+            infrastructure: {
+                zones: allResources.zones,
+                clusters: allResources.clusters,
+                instanceTypes: allResources.instanceTypes
+            },
+            _organization: 'semantic grouping by function'
+        };
+    }
+    catch (error) {
+        return {
+            error: `Failed to fetch resources: ${error.response?.data?.message || error.message}`,
+            available_endpoints: ['/groups', '/zones', '/service-plans', '/virtual-images', '/clusters'],
+            fallback_suggestion: 'Try checking individual resource types with specific API endpoints'
+        };
+    }
+}
+const server = new index_js_1.Server({
+    name: "vm-create-server",
+    version: "1.0.0"
+}, {
+    capabilities: {
+        tools: {
+            list: async () => ([
+                {
+                    name: "get_resources",
+                    description: "Discover and explore available VME infrastructure resources with intelligent filtering",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            type: {
+                                type: "string",
+                                description: "Resource type filter: 'compute', 'network', 'storage', 'vm', or leave empty for all"
+                            },
+                            intent: {
+                                type: "string",
+                                description: "Intent-based filtering: 'create', 'provision', 'list', 'discover', or natural language description"
+                            },
+                            role: {
+                                type: "string",
+                                description: "User role for permission-aware filtering (future enhancement)"
+                            }
+                        },
+                        required: []
+                    }
+                },
+                {
+                    name: "parse_vm_intent",
+                    description: "Parse natural language VM requests into structured parameters with confidence scoring",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            naturalLanguageInput: {
+                                type: "string",
+                                description: "Natural language description of VM provisioning request"
+                            }
+                        },
+                        required: ["naturalLanguageInput"]
+                    }
+                },
+                {
+                    name: "export_training_data",
+                    description: "Export AI training data for model improvement (requires ENABLE_AI_TRAINING_DATA=true)",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            format: {
+                                type: "string",
+                                description: "Export format: 'jsonl' or 'csv'",
+                                enum: ["jsonl", "csv"]
+                            },
+                            days: {
+                                type: "number",
+                                description: "Number of days of data to export (default: 7)"
+                            }
+                        },
+                        required: []
+                    }
+                },
+                {
+                    name: "provide_feedback",
+                    description: "Provide feedback on intent parsing accuracy to improve future predictions",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            original_input: {
+                                type: "string",
+                                description: "Original natural language input"
+                            },
+                            parsed_result: {
+                                type: "object",
+                                description: "The parsed result that was incorrect"
+                            },
+                            correct_interpretation: {
+                                type: "object",
+                                description: "What the correct interpretation should have been"
+                            },
+                            feedback_notes: {
+                                type: "string",
+                                description: "Additional notes about what went wrong"
+                            }
+                        },
+                        required: ["original_input", "feedback_notes"]
+                    }
+                },
+                {
+                    name: "create_vm",
+                    description: "Provision a new virtual machine",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            name: {
+                                type: "string",
+                                description: "Name for VM(s). Supports patterns like 'web01' or 'web01->web03' for multiple VMs"
+                            },
+                            group: {
+                                type: "string",
+                                description: "Group/site where VM will be created"
+                            },
+                            cloud: {
+                                type: "string",
+                                description: "Cloud/zone where VM will be provisioned (also accepts 'zone')"
+                            },
+                            zone: {
+                                type: "string",
+                                description: "Zone/cloud where VM will be provisioned (alias for 'cloud')"
+                            },
+                            template: {
+                                type: "string",
+                                description: "VM template or operating system"
+                            },
+                            size: {
+                                type: "string",
+                                description: "VM size (small, medium, 4GB, 8GB, etc.)"
+                            },
+                            distribution: {
+                                type: "string",
+                                description: "VM distribution strategy: 'auto' (default), 'spread' (across all nodes), or 'node1,node2,node3' (specific nodes)"
+                            },
+                            count: {
+                                type: "number",
+                                description: "Number of VMs to create (alternative to name patterns)"
+                            }
+                        },
+                        required: ["name", "group", "template", "size"]
+                    }
+                }
+            ]),
+            call: async (req) => {
+                if (req.tool === "get_resources") {
+                    const { type, intent, role } = req.arguments;
+                    const resources = await getResources(type, intent, role);
+                    return {
+                        toolResult: JSON.stringify(resources, null, 2),
+                        isError: !!resources.error
+                    };
+                }
+                if (req.tool === "parse_vm_intent") {
+                    const startTime = Date.now();
+                    const { naturalLanguageInput } = req.arguments;
+                    const sessionId = generateSessionId();
+                    const parsedIntent = parseVMIntent(naturalLanguageInput);
+                    const parseTime = Date.now() - startTime;
+                    // Log interaction for AI training (respects privacy settings)
+                    logInteraction({
+                        session_id: sessionId,
+                        tool_name: 'parse_vm_intent',
+                        user_input: { naturalLanguageInput },
+                        parsed_output: parsedIntent,
+                        success_metrics: {
+                            operation_success: parsedIntent.action !== 'unknown',
+                            confidence_score: parsedIntent.confidence,
+                            entities_extracted: Object.keys(parsedIntent.entities).length
+                        },
+                        timing: {
+                            parse_duration_ms: parseTime,
+                            total_duration_ms: parseTime
+                        }
+                    });
+                    return {
+                        toolResult: JSON.stringify(parsedIntent, null, 2),
+                        isError: parsedIntent.action === 'unknown' && parsedIntent.confidence < 0.3
+                    };
+                }
+                if (req.tool === "export_training_data") {
+                    if (!AI_TRAINING_ENABLED) {
+                        return {
+                            toolResult: JSON.stringify({
+                                error: "Training data collection is disabled",
+                                message: "Set ENABLE_AI_TRAINING_DATA=true in .env to enable data collection and export"
+                            }, null, 2),
+                            isError: true
+                        };
+                    }
+                    const { format = "jsonl", days = 7 } = req.arguments;
+                    try {
+                        const logsDir = (0, path_1.join)(process.cwd(), 'ai-training-logs');
+                        if (!(0, fs_1.existsSync)(logsDir)) {
+                            return {
+                                toolResult: JSON.stringify({
+                                    message: "No training data found",
+                                    data_count: 0
+                                }, null, 2),
+                                isError: false
+                            };
+                        }
+                        // Collect data from last N days
+                        const cutoffDate = new Date(Date.now() - (days * 24 * 60 * 60 * 1000));
+                        const allData = [];
+                        // Read log files and aggregate data
+                        const { readdirSync } = require('fs');
+                        const logFiles = readdirSync(logsDir).filter((file) => file.startsWith('interactions-') && file.endsWith('.jsonl'));
+                        for (const file of logFiles) {
+                            const fileDate = new Date(file.replace('interactions-', '').replace('.jsonl', ''));
+                            if (fileDate >= cutoffDate) {
+                                const content = (0, fs_1.readFileSync)((0, path_1.join)(logsDir, file), 'utf-8');
+                                const lines = content.trim().split('\n').filter(line => line.trim());
+                                for (const line of lines) {
+                                    try {
+                                        allData.push(JSON.parse(line));
+                                    }
+                                    catch (e) {
+                                        // Skip malformed lines
+                                    }
+                                }
+                            }
+                        }
+                        return {
+                            toolResult: JSON.stringify({
+                                message: `Exported ${allData.length} training data records from last ${days} days`,
+                                format: format,
+                                data_count: allData.length,
+                                data: format === 'jsonl' ? allData : allData.map(item => ({
+                                    timestamp: item.timestamp,
+                                    tool: item.tool_name,
+                                    user_input: JSON.stringify(item.user_input),
+                                    parsed_output: JSON.stringify(item.parsed_output),
+                                    success: item.success_metrics?.operation_success,
+                                    confidence: item.success_metrics?.confidence_score
+                                }))
+                            }, null, 2),
+                            isError: false
+                        };
+                    }
+                    catch (error) {
+                        return {
+                            toolResult: JSON.stringify({
+                                error: "Failed to export training data",
+                                message: error.message
+                            }, null, 2),
+                            isError: true
+                        };
+                    }
+                }
+                if (req.tool === "provide_feedback") {
+                    const { original_input, parsed_result, correct_interpretation, feedback_notes } = req.arguments;
+                    const sessionId = generateSessionId();
+                    // Log feedback for future model improvements
+                    logInteraction({
+                        session_id: sessionId,
+                        tool_name: 'provide_feedback',
+                        user_input: { original_input, feedback_notes },
+                        parsed_output: { parsed_result, correct_interpretation },
+                        user_feedback: feedback_notes,
+                        success_metrics: {
+                            operation_success: false, // This indicates the original parsing was wrong
+                            user_satisfaction: 0 // User had to provide feedback = dissatisfied
+                        }
+                    });
+                    return {
+                        toolResult: JSON.stringify({
+                            message: "Thank you for the feedback! This will help improve future intent recognition.",
+                            feedback_recorded: true,
+                            original_input: original_input,
+                            feedback_notes: feedback_notes
+                        }, null, 2),
+                        isError: false
+                    };
+                }
+                if (req.tool !== "create_vm")
+                    return;
+                const { name, group, cloud, zone, template, size, distribution, count } = req.arguments;
+                // Allow both 'cloud' and 'zone' parameters interchangeably
+                const location = cloud || zone;
+                if (!location) {
+                    return {
+                        error: {
+                            code: "missing_location",
+                            message: "Either 'cloud' or 'zone' parameter is required"
+                        }
+                    };
+                }
+                // Parse VM names and determine distribution strategy
+                const vmNames = parseVMNames(name, count);
+                const nodes = await getClusterNodes();
+                // Determine node assignment strategy
+                let nodeAssignments = [];
+                if (distribution === 'spread' || (vmNames.length > 1 && !distribution)) {
+                    // Distribute VMs across all available nodes
+                    vmNames.forEach((vmName, index) => {
+                        const nodeId = nodes[index % nodes.length];
+                        nodeAssignments.push({ name: vmName, kvmHostId: nodeId });
+                    });
+                }
+                else if (distribution && distribution !== 'auto') {
+                    // Parse specific node assignments like "1,2,3" or "node1,node2,node3"
+                    const specifiedNodes = distribution.split(',').map((n) => {
+                        const trimmed = n.trim();
+                        return trimmed.startsWith('node') ? parseInt(trimmed.replace('node', '')) : parseInt(trimmed);
+                    }).filter((n) => !isNaN(n));
+                    if (specifiedNodes.length > 0) {
+                        vmNames.forEach((vmName, index) => {
+                            const nodeId = specifiedNodes[index % specifiedNodes.length];
+                            nodeAssignments.push({ name: vmName, kvmHostId: nodeId });
+                        });
+                    }
+                    else {
+                        nodeAssignments = vmNames.map(vmName => ({ name: vmName }));
+                    }
+                }
+                else {
+                    // Auto-placement (no kvmHostId specified)
+                    nodeAssignments = vmNames.map(vmName => ({ name: vmName }));
+                }
+                const resolved = await resolveInput({ group, cloud: location, template, size });
+                const { groupId, cloudId, instanceTypeId, servicePlanId, imageId } = resolved;
+                if (!groupId || !cloudId || !instanceTypeId || !servicePlanId || !imageId) {
+                    const errors = [];
+                    if (!groupId)
+                        errors.push(`Group '${group}' not found. Available: ${resolved.availableGroups.join(', ')}`);
+                    if (!cloudId)
+                        errors.push(`Zone/Cloud '${location}' not found. Available: ${resolved.availableZones.join(', ')}`);
+                    if (!instanceTypeId)
+                        errors.push(`Instance type could not be resolved`);
+                    if (!servicePlanId)
+                        errors.push(`Size '${size}' could not be resolved to service plan`);
+                    if (!imageId)
+                        errors.push(`Template '${template}' could not be resolved to OS image`);
+                    return {
+                        error: {
+                            code: "resolution_failed",
+                            message: `Failed to resolve parameters:\n${errors.join('\n')}`
+                        }
+                    };
+                }
+                // Create VMs sequentially
+                const results = [];
+                const errors = [];
+                for (const assignment of nodeAssignments) {
+                    const vmConfig = {
+                        resourcePoolId: 'pool-1',
+                        poolProviderType: 'mvm',
+                        imageId: imageId,
+                        createUser: true
+                    };
+                    // Add kvmHostId only if explicitly specified
+                    if (assignment.kvmHostId) {
+                        vmConfig.kvmHostId = assignment.kvmHostId;
+                    }
+                    const payload = {
+                        zoneId: cloudId,
+                        instance: {
+                            name: assignment.name,
+                            cloud: 'tc-lab',
+                            hostName: assignment.name,
+                            type: 'mvm',
+                            instanceType: {
+                                code: 'mvm'
+                            },
+                            site: {
+                                id: groupId
+                            },
+                            layout: {
+                                id: 2, // Single HPE VM
+                                code: 'mvm-1.0-single'
+                            },
+                            plan: {
+                                id: servicePlanId
+                            }
+                        },
+                        config: vmConfig,
+                        volumes: [
+                            {
+                                id: -1,
+                                rootVolume: true,
+                                name: 'root',
+                                size: 10,
+                                storageType: 1,
+                                datastoreId: 5
+                            }
+                        ],
+                        networkInterfaces: [
+                            {
+                                primaryInterface: true,
+                                ipMode: 'dhcp',
+                                network: {
+                                    id: 'network-2'
+                                },
+                                networkInterfaceTypeId: 10
+                            }
+                        ],
+                        layoutSize: 1
+                    };
+                    try {
+                        const response = await api.post("/instances", payload);
+                        const vm = response.data?.instance;
+                        const nodeInfo = assignment.kvmHostId ? ` on node ${assignment.kvmHostId}` : ' (auto-placed)';
+                        results.push(`✅ '${vm.name}' created (ID: ${vm.id})${nodeInfo}`);
+                    }
+                    catch (err) {
+                        const nodeInfo = assignment.kvmHostId ? ` on node ${assignment.kvmHostId}` : '';
+                        errors.push(`❌ '${assignment.name}' failed${nodeInfo}: ${err.response?.data?.message || err.message}`);
+                    }
+                }
+                // Prepare response
+                const summary = [];
+                if (results.length > 0) {
+                    summary.push(`Successfully created ${results.length} VM(s):`);
+                    summary.push(...results);
+                }
+                if (errors.length > 0) {
+                    summary.push(`\nFailed to create ${errors.length} VM(s):`);
+                    summary.push(...errors);
+                }
+                summary.push(`\nResolved parameters:`);
+                summary.push(`- Group: ${resolved.resolvedGroup}`);
+                summary.push(`- Zone/Cloud: ${resolved.resolvedCloud}`);
+                summary.push(`- Template: ${resolved.resolvedImage}`);
+                summary.push(`- Plan: ${resolved.resolvedPlan}`);
+                if (distribution === 'spread' || (vmNames.length > 1 && !distribution)) {
+                    summary.push(`- Distribution: Spread across nodes ${nodes.join(', ')}`);
+                }
+                else if (nodeAssignments.some(a => a.kvmHostId)) {
+                    summary.push(`- Distribution: Specific node placement`);
+                }
+                else {
+                    summary.push(`- Distribution: Auto-placement`);
+                }
+                return {
+                    toolResult: summary.join('\n'),
+                    isError: errors.length > 0 && results.length === 0
+                };
+            }
+        }
+    }
+});
+const transport = new stdio_js_1.StdioServerTransport();
+server.connect(transport);