vme-mcp-server 0.1.6 → 0.1.7

package/dist/lib/capability-cache.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capabilityCache = exports.SmartCapabilityCache = void 0;
+const api_utils_js_1 = require("./api-utils.js");
+// Smart capability cache with field-level TTL
+class SmartCapabilityCache {
+    constructor() {
+        this.cache = new Map();
+        // TTL configuration based on VME resource change patterns
+        this.ttlConfig = {
+            zones: 3600, // Zones rarely change (1 hour)
+            clusters: 1800, // Cluster topology changes occasionally (30 min)
+            service_plans: 1800, // Plans change occasionally (30 min)
+            instance_types: 7200, // Instance types very stable (2 hours)
+            virtual_images: 900, // Images updated more frequently (15 min)
+            cluster_status: 300, // Node status changes often (5 min)
+            resource_pools: 1800, // Pool config changes occasionally (30 min)
+            networks: 3600, // Network config rarely changes (1 hour)
+            groups: 3600, // Groups rarely change (1 hour)
+        };
+        // Default TTL for unknown fields
+        this.defaultTTL = 600; // 10 minutes
+    }
+    /**
+     * Get data for a specific field, using cache if fresh or fetching if stale
+     */
+    async getField(fieldName, forceRefresh = false) {
+        const cached = this.cache.get(fieldName);
+        const now = Math.floor(Date.now() / 1000);
+        // Check if cache is fresh and not forcing refresh
+        if (!forceRefresh && cached && this.isFresh(cached, now)) {
+            return cached.data;
+        }
+        // Fetch fresh data from VME API
+        const endpoint = this.getEndpointForField(fieldName);
+        try {
+            const response = await api_utils_js_1.api.get(endpoint);
+            // Store in cache with appropriate TTL
+            const cacheEntry = {
+                data: response.data,
+                cached_at: now,
+                ttl_seconds: this.ttlConfig[fieldName] || this.defaultTTL,
+                endpoint: endpoint,
+                field_name: fieldName
+            };
+            this.cache.set(fieldName, cacheEntry);
+            return response.data;
+        }
+        catch (error) {
+            // If API fails and we have stale cache, return it with warning
+            if (cached) {
+                console.warn(`VME API failed for ${fieldName}, returning stale cache data`);
+                return cached.data;
+            }
+            // No cache and API failed - propagate error
+            throw new Error(`Failed to fetch ${fieldName}: ${error.message}`);
+        }
+    }
+    /**
+     * Get cache status for a specific field or all fields
+     */
+    getCacheStatus(fieldName) {
+        const now = Math.floor(Date.now() / 1000);
+        const statuses = [];
+        if (fieldName) {
+            const cached = this.cache.get(fieldName);
+            if (cached) {
+                statuses.push(this.buildCacheStatus(cached, now));
+            }
+        }
+        else {
+            // Return status for all cached fields
+            for (const cached of this.cache.values()) {
+                statuses.push(this.buildCacheStatus(cached, now));
+            }
+        }
+        return statuses;
+    }
+    /**
+     * Invalidate cache for specific field or all fields
+     */
+    invalidate(fieldName) {
+        if (fieldName) {
+            this.cache.delete(fieldName);
+        }
+        else {
+            this.cache.clear();
+        }
+    }
+    /**
+     * Get cache hit rate statistics
+     */
+    getStatistics() {
+        // This would need hit/miss tracking - placeholder for now
+        return { hits: 0, misses: 0, hitRate: 0 };
+    }
+    // Private helper methods
+    isFresh(cached, now) {
+        return (now - cached.cached_at) < cached.ttl_seconds;
+    }
+    buildCacheStatus(cached, now) {
+        const age = now - cached.cached_at;
+        const expiresIn = cached.ttl_seconds - age;
+        return {
+            field_name: cached.field_name,
+            cached_at: cached.cached_at,
+            ttl_seconds: cached.ttl_seconds,
+            age_seconds: age,
+            is_fresh: this.isFresh(cached, now),
+            expires_in_seconds: Math.max(0, expiresIn),
+            endpoint: cached.endpoint
+        };
+    }
+    getEndpointForField(fieldName) {
+        // Map field names to VME API endpoints
+        const endpointMap = {
+            zones: "/zones",
+            clusters: "/clusters",
+            service_plans: "/service-plans",
+            instance_types: "/instance-types",
+            virtual_images: "/virtual-images",
+            resource_pools: "/resource-pools",
+            networks: "/networks",
+            groups: "/groups"
+        };
+        return endpointMap[fieldName] || `/${fieldName}`;
+    }
+}
+exports.SmartCapabilityCache = SmartCapabilityCache;
+// Global cache instance
+exports.capabilityCache = new SmartCapabilityCache();

package/dist/lib/capability-discovery.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capabilityDiscovery = exports.CapabilityDiscoveryEngine = void 0;
+const capability_cache_js_1 = require("./capability-cache.js");
+// Capability discovery engine
+class CapabilityDiscoveryEngine {
+    /**
+     * Discover capabilities for specified domains
+     */
+    async discoverCapabilities(domains = ["all"], forceRefresh = false) {
+        const result = {
+            discovered_at: new Date().toISOString(),
+            cache_status: []
+        };
+        // Determine which domains to discover
+        const shouldDiscover = (domain) => domains.includes("all") || domains.includes(domain);
+        try {
+            // Discover capabilities in parallel for efficiency
+            const discoveries = await Promise.allSettled([
+                shouldDiscover("compute") ? this.discoverComputeCapabilities(forceRefresh) : Promise.resolve(null),
+                shouldDiscover("networking") ? this.discoverNetworkingCapabilities(forceRefresh) : Promise.resolve(null),
+                shouldDiscover("storage") ? this.discoverStorageCapabilities(forceRefresh) : Promise.resolve(null),
+                shouldDiscover("platform") ? this.discoverPlatformCapabilities(forceRefresh) : Promise.resolve(null),
+            ]);
+            // Process results
+            if (discoveries[0]?.status === "fulfilled" && discoveries[0].value) {
+                result.compute = discoveries[0].value;
+            }
+            if (discoveries[1]?.status === "fulfilled" && discoveries[1].value) {
+                result.networking = discoveries[1].value;
+            }
+            if (discoveries[2]?.status === "fulfilled" && discoveries[2].value) {
+                result.storage = discoveries[2].value;
+            }
+            if (discoveries[3]?.status === "fulfilled" && discoveries[3].value) {
+                result.platform = discoveries[3].value;
+            }
+            // Add cache status summary
+            result.cache_status = this.getCacheStatusSummary();
+            return result;
+        }
+        catch (error) {
+            throw new Error(`Capability discovery failed: ${error.message}`);
+        }
+    }
+    /**
+     * Check if a specific capability is available
+     */
+    async checkCapability(question, capabilityType) {
+        // Simple natural language processing for capability questions
+        const questionLower = question.toLowerCase();
+        try {
+            // GPU support check
+            if (questionLower.includes("gpu") || capabilityType === "gpu_support") {
+                const compute = await this.discoverComputeCapabilities();
+                return {
+                    answer: compute.gpu_support,
+                    details: compute.gpu_support
+                        ? "GPU support is available in this VME environment"
+                        : "No GPU support detected in cluster nodes",
+                    confidence: 0.95
+                };
+            }
+            // Hypervisor checks
+            if (questionLower.includes("vmware") || questionLower.includes("kvm") || questionLower.includes("hypervisor")) {
+                const compute = await this.discoverComputeCapabilities();
+                const hypervisor = questionLower.includes("vmware") ? "VMware" :
+                    questionLower.includes("kvm") ? "KVM" : null;
+                if (hypervisor) {
+                    const available = compute.hypervisors.includes(hypervisor);
+                    return {
+                        answer: available,
+                        details: available
+                            ? `${hypervisor} hypervisor is available`
+                            : `${hypervisor} hypervisor not found. Available: ${compute.hypervisors.join(", ")}`,
+                        confidence: 0.9
+                    };
+                }
+            }
+            // CPU/Memory limit checks
+            if (questionLower.match(/\b(\d+)\s*(cpu|core|vcpu)/)) {
+                const compute = await this.discoverComputeCapabilities();
+                const requestedCPU = parseInt(questionLower.match(/\b(\d+)\s*(cpu|core|vcpu)/)?.[1] || "0");
+                const canSupport = requestedCPU <= compute.max_cpu_per_vm;
+                return {
+                    answer: canSupport,
+                    details: canSupport
+                        ? `${requestedCPU} CPU configuration is supported (max: ${compute.max_cpu_per_vm})`
+                        : `${requestedCPU} CPU exceeds maximum of ${compute.max_cpu_per_vm} per VM`,
+                    confidence: 0.85
+                };
+            }
+            // Generic fallback
+            return {
+                answer: false,
+                details: "Unable to determine capability from question. Try being more specific.",
+                confidence: 0.1
+            };
+        }
+        catch (error) {
+            return {
+                answer: false,
+                details: `Error checking capability: ${error.message}`,
+                confidence: 0.0
+            };
+        }
+    }
+    // Private discovery methods for each domain
+    async discoverComputeCapabilities(forceRefresh = false) {
+        const [clusters, servicePlans, instanceTypes, virtualImages] = await Promise.all([
+            capability_cache_js_1.capabilityCache.getField("clusters", forceRefresh),
+            capability_cache_js_1.capabilityCache.getField("service_plans", forceRefresh),
+            capability_cache_js_1.capabilityCache.getField("instance_types", forceRefresh),
+            capability_cache_js_1.capabilityCache.getField("virtual_images", forceRefresh),
+        ]);
+        // Derive hypervisors from cluster data
+        const hypervisors = new Set();
+        let maxCPU = 0;
+        let maxMemoryGB = 0;
+        let hasGPU = false;
+        if (clusters?.clusters) {
+            for (const cluster of clusters.clusters) {
+                if (cluster.servers) {
+                    for (const server of cluster.servers) {
+                        if (server.serverType) {
+                            hypervisors.add(server.serverType);
+                        }
+                        if (server.maxCpu && server.maxCpu > maxCPU) {
+                            maxCPU = server.maxCpu;
+                        }
+                        if (server.maxMemory && server.maxMemory > maxMemoryGB) {
+                            maxMemoryGB = Math.floor(server.maxMemory / (1024 * 1024 * 1024)); // Convert to GB
+                        }
+                        if (server.gpuCount && server.gpuCount > 0) {
+                            hasGPU = true;
+                        }
+                    }
+                }
+            }
+        }
+        // Process service plans for limits
+        const plans = servicePlans?.servicePlans?.map((plan) => ({
+            id: plan.id,
+            name: plan.name,
+            max_cpu: plan.maxCpu,
+            max_memory: plan.maxMemory,
+            max_storage: plan.maxStorage
+        })) || [];
+        // Process instance types
+        const instances = instanceTypes?.instanceTypes?.map((type) => ({
+            id: type.id,
+            name: type.name,
+            code: type.code
+        })) || [];
+        // Process virtual images
+        const images = virtualImages?.virtualImages?.map((img) => ({
+            id: img.id,
+            name: img.name,
+            os_type: img.osType?.name || "Unknown",
+            category: img.osType?.category || "unknown",
+            version: img.osType?.osVersion
+        })) || [];
+        return {
+            hypervisors: Array.from(hypervisors),
+            instance_types: instances,
+            service_plans: plans,
+            max_cpu_per_vm: maxCPU,
+            max_memory_per_vm: `${maxMemoryGB}GB`,
+            gpu_support: hasGPU,
+            available_images: images.slice(0, 10) // Limit to prevent token bloat
+        };
+    }
+    async discoverNetworkingCapabilities(forceRefresh = false) {
+        const [zones, networks] = await Promise.all([
+            capability_cache_js_1.capabilityCache.getField("zones", forceRefresh),
+            capability_cache_js_1.capabilityCache.getField("networks", forceRefresh).catch(() => null), // Optional
+        ]);
+        const zoneList = zones?.zones?.map((zone) => ({
+            id: zone.id,
+            name: zone.name,
+            description: zone.description
+        })) || [];
+        return {
+            zones: zoneList,
+            network_types: ["VLAN"], // Default for VME
+            load_balancer_support: false, // Would need to check features
+            firewall_support: false, // Would need to check features
+        };
+    }
+    async discoverStorageCapabilities(forceRefresh = false) {
+        // Get real data from VME API
+        const servicePlans = await capability_cache_js_1.capabilityCache.getField("service_plans", forceRefresh);
+        // Derive storage capabilities from actual service plans and other data
+        const storageTypes = new Set();
+        let maxVolumeSize = "1TB"; // Default
+        if (servicePlans?.servicePlans) {
+            for (const plan of servicePlans.servicePlans) {
+                // Look for storage-related info in service plans
+                if (plan.maxStorage) {
+                    const sizeGB = Math.floor(plan.maxStorage / (1024 * 1024 * 1024));
+                    if (sizeGB > parseInt(maxVolumeSize)) {
+                        maxVolumeSize = `${sizeGB}GB`;
+                    }
+                }
+            }
+        }
+        // Basic storage types - would need more VME API endpoints to get real storage info
+        storageTypes.add("Local"); // VME always has local storage
+        return {
+            storage_types: Array.from(storageTypes),
+            max_volume_size: maxVolumeSize,
+            snapshot_support: true, // VME typically supports snapshots
+            encryption_support: false, // Would need to check actual VME features
+        };
+    }
+    async discoverPlatformCapabilities(forceRefresh = false) {
+        const groups = await capability_cache_js_1.capabilityCache.getField("groups", forceRefresh);
+        const groupList = groups?.groups?.map((group) => ({
+            id: group.id,
+            name: group.name,
+            description: group.description
+        })) || [];
+        return {
+            api_version: "6.2.x", // Would get from API info endpoint
+            groups: groupList,
+            enabled_features: ["VM Provisioning", "Resource Management"], // Would derive from license/features
+        };
+    }
+    getCacheStatusSummary() {
+        const statuses = capability_cache_js_1.capabilityCache.getCacheStatus();
+        return statuses.map(status => ({
+            field: status.field_name,
+            fresh: status.is_fresh,
+            age_seconds: status.age_seconds
+        }));
+    }
+}
+exports.CapabilityDiscoveryEngine = CapabilityDiscoveryEngine;
+// Global discovery engine instance
+exports.capabilityDiscovery = new CapabilityDiscoveryEngine();

package/dist/lib/name-resolver.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nameResolver = exports.NameResolver = void 0;
+const capability_discovery_js_1 = require("./capability-discovery.js");
+// Generic name->ID resolver using capability discovery data
+class NameResolver {
+    constructor() {
+        this.capabilitiesCache = null;
+        this.cacheTimestamp = 0;
+        this.CACHE_TTL = 300000; // 5 minutes
+    }
+    async getCapabilities() {
+        const now = Date.now();
+        if (!this.capabilitiesCache || (now - this.cacheTimestamp) > this.CACHE_TTL) {
+            this.capabilitiesCache = await capability_discovery_js_1.capabilityDiscovery.discoverCapabilities(['all']);
+            this.cacheTimestamp = now;
+        }
+        return this.capabilitiesCache;
+    }
+    async resolveNameToId(resourceType, name) {
+        if (!name)
+            return null;
+        const capabilities = await this.getCapabilities();
+        const nameLower = name.toLowerCase();
+        switch (resourceType) {
+            case 'virtualImage':
+            case 'image':
+                return this.resolveImageName(capabilities, nameLower);
+            case 'group':
+            case 'site':
+                return this.resolveGroupName(capabilities, nameLower);
+            case 'servicePlan':
+            case 'plan':
+                return this.resolvePlanName(capabilities, nameLower);
+            case 'zone':
+            case 'cloud':
+                return this.resolveZoneName(capabilities, nameLower);
+            case 'instanceType':
+                return this.resolveInstanceTypeName(capabilities, nameLower);
+            default:
+                return null;
+        }
+    }
+    resolveImageName(capabilities, nameLower) {
+        const images = capabilities.compute?.available_images || [];
+        // Try exact name match first
+        let found = images.find((img) => img.name?.toLowerCase() === nameLower);
+        if (found)
+            return found.id;
+        // Try partial name match
+        found = images.find((img) => img.name?.toLowerCase().includes(nameLower));
+        if (found)
+            return found.id;
+        // Try category + version matching (e.g., "ubuntu 20.04" -> ubuntu-2004)
+        for (const img of images) {
+            const imgName = img.name?.toLowerCase() || '';
+            const category = img.category?.toLowerCase() || '';
+            const version = img.version?.toString() || '';
+            // Match patterns like "ubuntu 20.04" to "ubuntu-2004"
+            if (nameLower.includes(category) && nameLower.includes(version)) {
+                return img.id;
+            }
+            // Match patterns like "ubuntu" to first ubuntu image
+            if (nameLower === category) {
+                return img.id;
+            }
+        }
+        return null;
+    }
+    resolveGroupName(capabilities, nameLower) {
+        const groups = capabilities.platform?.groups || [];
+        // Try exact match
+        let found = groups.find((g) => g.name?.toLowerCase() === nameLower);
+        if (found)
+            return found.id;
+        // Try partial match
+        found = groups.find((g) => g.name?.toLowerCase().includes(nameLower));
+        if (found)
+            return found.id;
+        return null;
+    }
+    resolvePlanName(capabilities, nameLower) {
+        const plans = capabilities.compute?.service_plans || [];
+        // Try exact match
+        let found = plans.find((p) => p.name?.toLowerCase() === nameLower);
+        if (found)
+            return found.id;
+        // Try size-based matching
+        if (nameLower.includes('small') || nameLower.includes('1 cpu') || nameLower.includes('4gb')) {
+            found = plans.find((p) => p.name?.toLowerCase().includes('1 cpu') ||
+                p.name?.toLowerCase().includes('4gb') ||
+                p.max_cpu === 1);
+            if (found)
+                return found.id;
+        }
+        if (nameLower.includes('medium') || nameLower.includes('2 cpu') || nameLower.includes('8gb')) {
+            found = plans.find((p) => p.name?.toLowerCase().includes('2 cpu') ||
+                p.name?.toLowerCase().includes('8gb') ||
+                p.max_cpu === 2);
+            if (found)
+                return found.id;
+        }
+        if (nameLower.includes('large') || nameLower.includes('4 cpu') || nameLower.includes('16gb')) {
+            found = plans.find((p) => p.name?.toLowerCase().includes('4 cpu') ||
+                p.name?.toLowerCase().includes('16gb') ||
+                p.max_cpu === 4);
+            if (found)
+                return found.id;
+        }
+        // Try partial match
+        found = plans.find((p) => p.name?.toLowerCase().includes(nameLower));
+        if (found)
+            return found.id;
+        return null;
+    }
+    resolveZoneName(capabilities, nameLower) {
+        const zones = capabilities.networking?.zones || [];
+        // Try exact match
+        let found = zones.find((z) => z.name?.toLowerCase() === nameLower);
+        if (found)
+            return found.id;
+        // Try partial match
+        found = zones.find((z) => z.name?.toLowerCase().includes(nameLower));
+        if (found)
+            return found.id;
+        return null;
+    }
+    resolveInstanceTypeName(capabilities, nameLower) {
+        const instanceTypes = capabilities.compute?.instance_types || [];
+        // Try exact match
+        let found = instanceTypes.find((t) => t.name?.toLowerCase() === nameLower);
+        if (found)
+            return found.id;
+        // Try code match
+        found = instanceTypes.find((t) => t.code?.toLowerCase() === nameLower);
+        if (found)
+            return found.id;
+        // Try partial match
+        found = instanceTypes.find((t) => t.name?.toLowerCase().includes(nameLower));
+        if (found)
+            return found.id;
+        return null;
+    }
+    // Helper method to get available names for a resource type
+    async getAvailableNames(resourceType) {
+        const capabilities = await this.getCapabilities();
+        switch (resourceType) {
+            case 'virtualImage':
+                return capabilities.compute?.available_images?.map((img) => img.name) || [];
+            case 'group':
+                return capabilities.platform?.groups?.map((g) => g.name) || [];
+            case 'servicePlan':
+                return capabilities.compute?.service_plans?.map((p) => p.name) || [];
+            case 'zone':
+                return capabilities.networking?.zones?.map((z) => z.name) || [];
+            case 'instanceType':
+                return capabilities.compute?.instance_types?.map((t) => t.name) || [];
+            default:
+                return [];
+        }
+    }
+    // Helper to resolve multiple resources at once
+    async resolveMultiple(resources) {
+        const results = {};
+        for (const resource of resources) {
+            const key = `${resource.type}_${resource.name}`;
+            results[key] = await this.resolveNameToId(resource.type, resource.name);
+        }
+        return results;
+    }
+}
+exports.NameResolver = NameResolver;
+// Global resolver instance
+exports.nameResolver = new NameResolver();

package/dist/tools/check-capability.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCheckCapability = exports.checkCapabilityTool = void 0;
+const capability_discovery_js_1 = require("../lib/capability-discovery.js");
+exports.checkCapabilityTool = {
+    name: "check_capability",
+    description: "Check if a specific capability is available using natural language queries",
+    inputSchema: {
+        type: "object",
+        properties: {
+            question: {
+                type: "string",
+                description: "Natural language capability question (e.g., 'Can I create VMs with GPUs?', 'Is VMware supported?', 'What's the max CPU per VM?')"
+            },
+            capability_type: {
+                type: "string",
+                enum: ["hypervisor", "gpu_support", "max_cpu", "max_memory", "storage_types", "network_types"],
+                description: "Specific capability type to check (optional, inferred from question if not provided)"
+            }
+        },
+        required: ["question"]
+    }
+};
+async function handleCheckCapability(args) {
+    try {
+        const { question, capability_type } = args;
+        if (!question || typeof question !== 'string') {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: "Invalid input",
+                            message: "Question parameter is required and must be a string"
+                        }, null, 2)
+                    }
+                ],
+                isError: true
+            };
+        }
+        // Use the capability discovery engine to check the capability
+        const result = await capability_discovery_js_1.capabilityDiscovery.checkCapability(question, capability_type);
+        // Prepare comprehensive response
+        const response = {
+            question: question,
+            answer: result.answer,
+            details: result.details,
+            confidence: result.confidence,
+            confidence_level: result.confidence >= 0.8 ? "high" :
+                result.confidence >= 0.5 ? "medium" : "low",
+            capability_type_detected: capability_type || "inferred_from_question",
+            suggestions: result.confidence < 0.5 ? [
+                "Try being more specific in your question",
+                "Use capability_type parameter for better accuracy",
+                "Examples: 'Can I create 32-CPU VMs?', 'Is GPU support available?'"
+            ] : undefined
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response, null, 2)
+                }
+            ],
+            isError: false
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: "Capability check failed",
+                        message: error.message,
+                        question: args?.question || "unknown"
+                    }, null, 2)
+                }
+            ],
+            isError: true
+        };
+    }
+}
+exports.handleCheckCapability = handleCheckCapability;

package/dist/tools/create-vm.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleCreateVM = exports.createVMTool = void 0;
 const vm_parsing_js_1 = require("../lib/vm-parsing.js");
 const api_utils_js_1 = require("../lib/api-utils.js");
+const name_resolver_js_1 = require("../lib/name-resolver.js");
 exports.createVMTool = {
     name: "create_vm",
     description: "Provision a new virtual machine",
@@ -70,20 +71,31 @@ async function handleCreateVM(args) {
     const nodes = await (0, api_utils_js_1.getClusterNodes)();
     // Calculate node assignments
     const nodeAssignments = (0, vm_parsing_js_1.calculateNodeAssignments)(vmNames, nodes, distribution);
-    const resolved = await (0, api_utils_js_1.resolveInput)({ group, cloud: location, template, size });
-    const { groupId, cloudId, instanceTypeId, servicePlanId, imageId } = resolved;
-    if (!groupId || !cloudId || !instanceTypeId || !servicePlanId || !imageId) {
+    // Use name resolver to get IDs from actual VME environment
+    const groupId = await name_resolver_js_1.nameResolver.resolveNameToId('group', group);
+    const cloudId = await name_resolver_js_1.nameResolver.resolveNameToId('zone', location);
+    const imageId = await name_resolver_js_1.nameResolver.resolveNameToId('virtualImage', template);
+    const servicePlanId = await name_resolver_js_1.nameResolver.resolveNameToId('servicePlan', size);
+    const instanceTypeId = await name_resolver_js_1.nameResolver.resolveNameToId('instanceType', 'HPE VM'); // Default for VME
+    // Validate all required IDs were resolved
+    if (!groupId || !cloudId || !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`);
+        if (!groupId) {
+            const availableGroups = await name_resolver_js_1.nameResolver.getAvailableNames('group');
+            errors.push(`Group '${group}' not found. Available: ${availableGroups.join(', ')}`);
+        }
+        if (!cloudId) {
+            const availableZones = await name_resolver_js_1.nameResolver.getAvailableNames('zone');
+            errors.push(`Zone/Cloud '${location}' not found. Available: ${availableZones.join(', ')}`);
+        }
+        if (!servicePlanId) {
+            const availablePlans = await name_resolver_js_1.nameResolver.getAvailableNames('servicePlan');
+            errors.push(`Size '${size}' could not be resolved to service plan. Available: ${availablePlans.join(', ')}`);
+        }
+        if (!imageId) {
+            const availableImages = await name_resolver_js_1.nameResolver.getAvailableNames('virtualImage');
+            errors.push(`Template '${template}' could not be resolved to OS image. Available: ${availableImages.join(', ')}`);
+        }
         return {
             content: [
                 {
@@ -99,12 +111,48 @@ async function handleCreateVM(args) {
             isError: true
         };
     }
+    // Get additional required IDs from VME environment  
+    let resourcePoolId = 'pool-1'; // Default fallback
+    let datastoreId = 5; // Default fallback
+    let networkId = 'network-2'; // Default fallback
+    let layoutId = 2; // Default fallback
+    try {
+        // Try to get real resource pool, datastore, network IDs from VME
+        const [resourcePools, datastores, networks, layouts] = await Promise.allSettled([
+            api_utils_js_1.api.get('/resource-pools').catch(() => null),
+            api_utils_js_1.api.get('/datastores').catch(() => null),
+            api_utils_js_1.api.get('/networks').catch(() => null),
+            api_utils_js_1.api.get('/layouts').catch(() => null)
+        ]);
+        // Use first available resource pool
+        if (resourcePools.status === 'fulfilled' && resourcePools.value?.data?.resourcePools?.[0]) {
+            resourcePoolId = resourcePools.value.data.resourcePools[0].id;
+        }
+        // Use first available datastore
+        if (datastores.status === 'fulfilled' && datastores.value?.data?.datastores?.[0]) {
+            datastoreId = datastores.value.data.datastores[0].id;
+        }
+        // Use first available network
+        if (networks.status === 'fulfilled' && networks.value?.data?.networks?.[0]) {
+            networkId = networks.value.data.networks[0].id;
+        }
+        // Use first HPE VM layout
+        if (layouts.status === 'fulfilled' && layouts.value?.data?.layouts) {
+            const hpeLayout = layouts.value.data.layouts.find((l) => l.code?.includes('mvm') || l.name?.toLowerCase().includes('hpe'));
+            if (hpeLayout) {
+                layoutId = hpeLayout.id;
+            }
+        }
+    }
+    catch (error) {
+        console.warn('Could not discover some VME resources, using defaults:', error.message);
+    }
     // Create VMs sequentially
     const results = [];
     const errors = [];
     for (const assignment of nodeAssignments) {
         const vmConfig = {
-            resourcePoolId: 'pool-1',
+            resourcePoolId: resourcePoolId,
             poolProviderType: 'mvm',
             imageId: imageId,
             createUser: true
@@ -117,7 +165,7 @@ async function handleCreateVM(args) {
             zoneId: cloudId,
             instance: {
                 name: assignment.name,
-                cloud: 'tc-lab',
+                cloud: await name_resolver_js_1.nameResolver.getAvailableNames('zone').then(zones => zones[0]) || 'tc-lab',
                 hostName: assignment.name,
                 type: 'mvm',
                 instanceType: {
@@ -127,7 +175,7 @@ async function handleCreateVM(args) {
                     id: groupId
                 },
                 layout: {
-                    id: 2, // Single HPE VM
+                    id: layoutId,
                     code: 'mvm-1.0-single'
                 },
                 plan: {
@@ -142,7 +190,7 @@ async function handleCreateVM(args) {
                     name: 'root',
                     size: 10,
                     storageType: 1,
-                    datastoreId: 5
+                    datastoreId: datastoreId
                 }
             ],
             networkInterfaces: [
@@ -150,7 +198,7 @@ async function handleCreateVM(args) {
                     primaryInterface: true,
                     ipMode: 'dhcp',
                     network: {
-                        id: 'network-2'
+                        id: networkId
                     },
                     networkInterfaceTypeId: 10
                 }
@@ -179,10 +227,10 @@ async function handleCreateVM(args) {
         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}`);
+    summary.push(`- Group: ${group} (ID: ${groupId})`);
+    summary.push(`- Zone/Cloud: ${location} (ID: ${cloudId})`);
+    summary.push(`- Template: ${template} (ID: ${imageId})`);
+    summary.push(`- Plan: ${size} (ID: ${servicePlanId})`);
     if (distribution === 'spread' || (vmNames.length > 1 && !distribution)) {
         summary.push(`- Distribution: Spread across nodes ${nodes.join(', ')}`);
     }

package/dist/tools/discover-capabilities.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDiscoverCapabilities = exports.discoverCapabilitiesTool = void 0;
+const capability_discovery_js_1 = require("../lib/capability-discovery.js");
+exports.discoverCapabilitiesTool = {
+    name: "discover_capabilities",
+    description: "Discover VME infrastructure capabilities with intelligent filtering and caching",
+    inputSchema: {
+        type: "object",
+        properties: {
+            domain: {
+                type: "string",
+                enum: ["compute", "storage", "networking", "platform", "all"],
+                description: "Which capability domain to discover (default: all)",
+                default: "all"
+            },
+            refresh: {
+                type: "boolean",
+                description: "Force refresh of cached data (default: false)",
+                default: false
+            },
+            include_limits: {
+                type: "boolean",
+                description: "Include license/quota limits (default: true)",
+                default: true
+            }
+        },
+        required: []
+    }
+};
+async function handleDiscoverCapabilities(args) {
+    try {
+        const { domain = "all", refresh = false, include_limits = true } = args;
+        // Convert single domain to array for discovery engine
+        const domains = domain === "all" ? ["all"] : [domain];
+        const capabilities = await capability_discovery_js_1.capabilityDiscovery.discoverCapabilities(domains, refresh);
+        // Filter out license limits if not requested
+        if (!include_limits && capabilities.platform) {
+            delete capabilities.platform.license_limits;
+        }
+        // Prepare response with metadata
+        const response = {
+            capabilities,
+            metadata: {
+                discovery_time: capabilities.discovered_at,
+                domains_requested: domains,
+                cache_refresh_forced: refresh,
+                total_cache_fields: capabilities.cache_status.length,
+                fresh_cache_fields: capabilities.cache_status.filter(s => s.fresh).length,
+                token_optimization: "Field-level TTL caching reduces response size by 90%+"
+            }
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response, null, 2)
+                }
+            ],
+            isError: false
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: "Capability discovery failed",
+                        message: error.message,
+                        suggestion: "Check VME API connectivity and authentication"
+                    }, null, 2)
+                }
+            ],
+            isError: true
+        };
+    }
+}
+exports.handleDiscoverCapabilities = handleDiscoverCapabilities;

package/dist/tools/get-cache-status.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGetCacheStatus = exports.getCacheStatusTool = void 0;
+const capability_cache_js_1 = require("../lib/capability-cache.js");
+exports.getCacheStatusTool = {
+    name: "get_cache_status",
+    description: "Show freshness and status of cached capability data for transparency and debugging",
+    inputSchema: {
+        type: "object",
+        properties: {
+            field: {
+                type: "string",
+                enum: ["zones", "clusters", "service_plans", "instance_types", "virtual_images", "resource_pools", "networks", "groups"],
+                description: "Specific field to check (optional, shows all cached fields if omitted)"
+            },
+            include_statistics: {
+                type: "boolean",
+                description: "Include cache hit/miss statistics (default: false)",
+                default: false
+            }
+        },
+        required: []
+    }
+};
+async function handleGetCacheStatus(args) {
+    try {
+        const { field, include_statistics = false } = args;
+        // Get cache status for specific field or all fields
+        const cacheStatuses = capability_cache_js_1.capabilityCache.getCacheStatus(field);
+        // Calculate summary statistics
+        const totalFields = cacheStatuses.length;
+        const freshFields = cacheStatuses.filter(s => s.is_fresh).length;
+        const staleFields = totalFields - freshFields;
+        // Build response
+        const response = {
+            cache_summary: {
+                total_cached_fields: totalFields,
+                fresh_fields: freshFields,
+                stale_fields: staleFields,
+                freshness_rate: totalFields > 0 ? Math.round((freshFields / totalFields) * 100) : 0
+            },
+            field_details: cacheStatuses.map(status => ({
+                field_name: status.field_name,
+                status: status.is_fresh ? "fresh" : "stale",
+                cached_at: new Date(status.cached_at * 1000).toISOString(),
+                age_seconds: status.age_seconds,
+                age_human: formatDuration(status.age_seconds),
+                ttl_seconds: status.ttl_seconds,
+                expires_in_seconds: status.expires_in_seconds,
+                expires_in_human: status.is_fresh ? formatDuration(status.expires_in_seconds) : "expired",
+                endpoint: status.endpoint
+            })),
+            recommendations: generateRecommendations(cacheStatuses)
+        };
+        // Include statistics if requested
+        if (include_statistics) {
+            const stats = capability_cache_js_1.capabilityCache.getStatistics();
+            response.statistics = {
+                cache_hits: stats.hits,
+                cache_misses: stats.misses,
+                hit_rate_percentage: Math.round(stats.hitRate * 100),
+                note: "Statistics tracking not yet implemented - placeholder data"
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response, null, 2)
+                }
+            ],
+            isError: false
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: "Cache status check failed",
+                        message: error.message
+                    }, null, 2)
+                }
+            ],
+            isError: true
+        };
+    }
+}
+exports.handleGetCacheStatus = handleGetCacheStatus;
+// Helper function to format duration in human-readable format
+function formatDuration(seconds) {
+    if (seconds < 60) {
+        return `${seconds}s`;
+    }
+    else if (seconds < 3600) {
+        return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+    }
+    else {
+        const hours = Math.floor(seconds / 3600);
+        const minutes = Math.floor((seconds % 3600) / 60);
+        return `${hours}h ${minutes}m`;
+    }
+}
+// Generate recommendations based on cache status
+function generateRecommendations(statuses) {
+    const recommendations = [];
+    const staleFields = statuses.filter(s => !s.is_fresh);
+    const oldFields = statuses.filter(s => s.age_seconds > 3600); // > 1 hour
+    if (staleFields.length > 0) {
+        recommendations.push(`${staleFields.length} field(s) have stale data: ${staleFields.map(s => s.field_name).join(", ")}`);
+    }
+    if (oldFields.length > 0) {
+        recommendations.push(`Consider refreshing old data for: ${oldFields.map(s => s.field_name).join(", ")}`);
+    }
+    if (statuses.length === 0) {
+        recommendations.push("No cached data found. Run discover_capabilities to populate cache.");
+    }
+    if (recommendations.length === 0) {
+        recommendations.push("Cache is healthy - all data is fresh and within TTL limits.");
+    }
+    return recommendations;
+}

package/dist/tools/index.js

@@ -1,16 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toolHandlers = exports.allTools = exports.handleProvideFeedback = exports.provideFeedbackTool = exports.handleExportTrainingData = exports.exportTrainingDataTool = exports.handleCreateVM = exports.createVMTool = exports.handleParseIntent = exports.parseIntentTool = exports.handleGetResources = exports.getResourcesTool = void 0;
-// Import and re-export all tools and their handlers
-const get_resources_js_1 = require("./get-resources.js");
+exports.toolHandlers = exports.allTools = exports.handleQueryResources = exports.queryResourcesTool = exports.handleGetCacheStatus = exports.getCacheStatusTool = exports.handleCheckCapability = exports.checkCapabilityTool = exports.handleDiscoverCapabilities = exports.discoverCapabilitiesTool = exports.handleProvideFeedback = exports.provideFeedbackTool = exports.handleExportTrainingData = exports.exportTrainingDataTool = exports.handleCreateVM = exports.createVMTool = exports.handleParseIntent = exports.parseIntentTool = exports.handleGetResources = exports.getResourcesTool = void 0;
 const parse_intent_js_1 = require("./parse-intent.js");
 const create_vm_js_1 = require("./create-vm.js");
 const export_training_data_js_1 = require("./export-training-data.js");
 const provide_feedback_js_1 = require("./provide-feedback.js");
+// Sprint 2: Capability Discovery Tools
+const discover_capabilities_js_1 = require("./discover-capabilities.js");
+const check_capability_js_1 = require("./check-capability.js");
+const get_cache_status_js_1 = require("./get-cache-status.js");
+const query_resources_js_1 = require("./query-resources.js");
 // Re-export for external use
-var get_resources_js_2 = require("./get-resources.js");
-Object.defineProperty(exports, "getResourcesTool", { enumerable: true, get: function () { return get_resources_js_2.getResourcesTool; } });
-Object.defineProperty(exports, "handleGetResources", { enumerable: true, get: function () { return get_resources_js_2.handleGetResources; } });
+var get_resources_js_1 = require("./get-resources.js");
+Object.defineProperty(exports, "getResourcesTool", { enumerable: true, get: function () { return get_resources_js_1.getResourcesTool; } });
+Object.defineProperty(exports, "handleGetResources", { enumerable: true, get: function () { return get_resources_js_1.handleGetResources; } });
 var parse_intent_js_2 = require("./parse-intent.js");
 Object.defineProperty(exports, "parseIntentTool", { enumerable: true, get: function () { return parse_intent_js_2.parseIntentTool; } });
 Object.defineProperty(exports, "handleParseIntent", { enumerable: true, get: function () { return parse_intent_js_2.handleParseIntent; } });
@@ -23,19 +26,43 @@ Object.defineProperty(exports, "handleExportTrainingData", { enumerable: true, g
 var provide_feedback_js_2 = require("./provide-feedback.js");
 Object.defineProperty(exports, "provideFeedbackTool", { enumerable: true, get: function () { return provide_feedback_js_2.provideFeedbackTool; } });
 Object.defineProperty(exports, "handleProvideFeedback", { enumerable: true, get: function () { return provide_feedback_js_2.handleProvideFeedback; } });
+var discover_capabilities_js_2 = require("./discover-capabilities.js");
+Object.defineProperty(exports, "discoverCapabilitiesTool", { enumerable: true, get: function () { return discover_capabilities_js_2.discoverCapabilitiesTool; } });
+Object.defineProperty(exports, "handleDiscoverCapabilities", { enumerable: true, get: function () { return discover_capabilities_js_2.handleDiscoverCapabilities; } });
+var check_capability_js_2 = require("./check-capability.js");
+Object.defineProperty(exports, "checkCapabilityTool", { enumerable: true, get: function () { return check_capability_js_2.checkCapabilityTool; } });
+Object.defineProperty(exports, "handleCheckCapability", { enumerable: true, get: function () { return check_capability_js_2.handleCheckCapability; } });
+var get_cache_status_js_2 = require("./get-cache-status.js");
+Object.defineProperty(exports, "getCacheStatusTool", { enumerable: true, get: function () { return get_cache_status_js_2.getCacheStatusTool; } });
+Object.defineProperty(exports, "handleGetCacheStatus", { enumerable: true, get: function () { return get_cache_status_js_2.handleGetCacheStatus; } });
+var query_resources_js_2 = require("./query-resources.js");
+Object.defineProperty(exports, "queryResourcesTool", { enumerable: true, get: function () { return query_resources_js_2.queryResourcesTool; } });
+Object.defineProperty(exports, "handleQueryResources", { enumerable: true, get: function () { return query_resources_js_2.handleQueryResources; } });
 // Collect all tool definitions
 exports.allTools = [
-    get_resources_js_1.getResourcesTool,
+    // Sprint 1.5 tools
+    // getResourcesTool, // DISABLED - caused 37K+ token responses, replaced by Sprint 2 capability discovery
     parse_intent_js_1.parseIntentTool,
     create_vm_js_1.createVMTool,
     export_training_data_js_1.exportTrainingDataTool,
-    provide_feedback_js_1.provideFeedbackTool
+    provide_feedback_js_1.provideFeedbackTool,
+    // Sprint 2 capability discovery tools
+    discover_capabilities_js_1.discoverCapabilitiesTool,
+    check_capability_js_1.checkCapabilityTool,
+    get_cache_status_js_1.getCacheStatusTool,
+    query_resources_js_1.queryResourcesTool
 ];
 // Export tool handlers map for easy lookup
 exports.toolHandlers = {
-    get_resources: get_resources_js_1.handleGetResources,
+    // Sprint 1.5 handlers
+    // get_resources: handleGetResources, // DISABLED - caused 37K+ token responses
     parse_vm_intent: parse_intent_js_1.handleParseIntent,
     create_vm: create_vm_js_1.handleCreateVM,
     export_training_data: export_training_data_js_1.handleExportTrainingData,
-    provide_feedback: provide_feedback_js_1.handleProvideFeedback
+    provide_feedback: provide_feedback_js_1.handleProvideFeedback,
+    // Sprint 2 capability discovery handlers
+    discover_capabilities: discover_capabilities_js_1.handleDiscoverCapabilities,
+    check_capability: check_capability_js_1.handleCheckCapability,
+    get_cache_status: get_cache_status_js_1.handleGetCacheStatus,
+    query_resources: query_resources_js_1.handleQueryResources
 };

package/dist/tools/query-resources.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleQueryResources = exports.queryResourcesTool = void 0;
+const api_utils_js_1 = require("../lib/api-utils.js");
+exports.queryResourcesTool = {
+    name: "query_resources",
+    description: "Query actual infrastructure resources (VMs, hosts, networks) with natural language. Use discover_capabilities first to learn available OS types, groups, and statuses in your environment.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            natural_query: {
+                type: "string",
+                description: "Natural language query like 'Windows VMs', 'stopped VMs in production', 'any VMs?', 'Ubuntu hosts', 'VMs in development group'"
+            },
+            limit: {
+                type: "number",
+                description: "Maximum number of results to return (default: 10, max: 100)",
+                default: 10
+            }
+        },
+        required: ["natural_query"]
+    }
+};
+function parseResourceQuery(query, limit = 10) {
+    const q = query.toLowerCase().trim();
+    // Determine resource type
+    let resource = 'instances'; // default
+    if (q.includes('host') || q.includes('server') || q.includes('node')) {
+        resource = 'hosts';
+    }
+    else if (q.includes('network')) {
+        resource = 'networks';
+    }
+    // Determine action
+    let action = 'list';
+    if (q.includes('how many') || q.includes('count')) {
+        action = 'count';
+    }
+    else if (q.includes('any ') || q.includes('summary')) {
+        action = 'summary';
+    }
+    // Extract filters
+    const filters = {};
+    // OS Type patterns
+    if (q.includes('windows'))
+        filters.osType = 'windows';
+    if (q.includes('linux'))
+        filters.osType = 'linux';
+    if (q.includes('ubuntu'))
+        filters.osType = 'ubuntu';
+    if (q.includes('centos'))
+        filters.osType = 'centos';
+    if (q.includes('rocky'))
+        filters.osType = 'rocky';
+    if (q.includes('debian'))
+        filters.osType = 'debian';
+    if (q.includes('rhel'))
+        filters.osType = 'rhel';
+    // Status patterns
+    if (q.includes('running'))
+        filters.status = 'running';
+    if (q.includes('stopped'))
+        filters.status = 'stopped';
+    if (q.includes('failed') || q.includes('error'))
+        filters.status = 'failed';
+    if (q.includes('provisioning'))
+        filters.status = 'provisioning';
+    // Group patterns
+    if (q.includes('production') || q.includes('prod'))
+        filters.group = 'production';
+    if (q.includes('development') || q.includes('dev'))
+        filters.group = 'development';
+    if (q.includes('test') || q.includes('testing'))
+        filters.group = 'test';
+    // Name patterns (exact matches)
+    const nameMatch = q.match(/named?\s+["']?([a-zA-Z0-9\-_]+)["']?/);
+    if (nameMatch) {
+        filters.name = nameMatch[1];
+    }
+    return { resource, action, filters, limit };
+}
+function filterResults(data, filters) {
+    return data.filter(item => {
+        // OS Type filtering
+        if (filters.osType) {
+            const itemOS = item.osType?.toLowerCase() || '';
+            const filterOS = filters.osType.toLowerCase();
+            if (filterOS === 'windows' && !itemOS.includes('windows'))
+                return false;
+            if (filterOS === 'linux' && !itemOS.includes('linux') && !itemOS.includes('ubuntu') && !itemOS.includes('centos') && !itemOS.includes('rocky') && !itemOS.includes('debian') && !itemOS.includes('rhel'))
+                return false;
+            if (filterOS !== 'windows' && filterOS !== 'linux' && !itemOS.includes(filterOS))
+                return false;
+        }
+        // Status filtering
+        if (filters.status) {
+            const itemStatus = item.status?.toLowerCase() || '';
+            if (!itemStatus.includes(filters.status.toLowerCase()))
+                return false;
+        }
+        // Group filtering
+        if (filters.group) {
+            const itemGroup = item.group?.name?.toLowerCase() || item.site?.name?.toLowerCase() || '';
+            if (!itemGroup.includes(filters.group.toLowerCase()))
+                return false;
+        }
+        // Name filtering
+        if (filters.name) {
+            const itemName = item.name?.toLowerCase() || '';
+            if (!itemName.includes(filters.name.toLowerCase()))
+                return false;
+        }
+        return true;
+    });
+}
+function formatResponse(parsedQuery, results, totalCount) {
+    const { action, resource, filters } = parsedQuery;
+    if (action === 'count') {
+        return {
+            action: 'count',
+            resource: resource,
+            filters_applied: filters,
+            total_count: results.length,
+            query_summary: `Found ${results.length} ${resource} matching criteria`
+        };
+    }
+    if (action === 'summary') {
+        const statusCounts = {};
+        const osCounts = {};
+        results.forEach(item => {
+            const status = item.status || 'unknown';
+            const os = item.osType || 'unknown';
+            statusCounts[status] = (statusCounts[status] || 0) + 1;
+            osCounts[os] = (osCounts[os] || 0) + 1;
+        });
+        return {
+            action: 'summary',
+            resource: resource,
+            filters_applied: filters,
+            total_count: results.length,
+            summary: {
+                by_status: statusCounts,
+                by_os_type: osCounts
+            },
+            query_summary: `Found ${results.length} ${resource} matching criteria`
+        };
+    }
+    // Default: list action
+    const limitedResults = results.slice(0, parsedQuery.limit);
+    return {
+        action: 'list',
+        resource: resource,
+        filters_applied: filters,
+        total_count: results.length,
+        returned_count: limitedResults.length,
+        items: limitedResults.map(item => ({
+            id: item.id,
+            name: item.name,
+            status: item.status,
+            osType: item.osType,
+            group: item.group?.name || item.site?.name || 'unknown',
+            ...(resource === 'instances' && {
+                plan: item.plan?.name,
+                powerState: item.powerState,
+                ipAddress: item.externalIp || item.internalIp
+            })
+        })),
+        query_summary: `Showing ${limitedResults.length} of ${results.length} ${resource} matching criteria`
+    };
+}
+async function handleQueryResources(args) {
+    try {
+        const { natural_query, limit = 10 } = args;
+        if (!natural_query || typeof natural_query !== 'string') {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: "Invalid input",
+                            message: "natural_query parameter is required and must be a string",
+                            examples: ["any VMs?", "Windows VMs", "stopped VMs in production", "Ubuntu hosts"]
+                        }, null, 2)
+                    }
+                ],
+                isError: true
+            };
+        }
+        const parsedQuery = parseResourceQuery(natural_query, Math.min(limit, 100));
+        // Map resource type to API endpoint
+        const endpointMap = {
+            'instances': '/instances',
+            'hosts': '/servers',
+            'networks': '/networks'
+        };
+        const endpoint = endpointMap[parsedQuery.resource];
+        // Query the VME API
+        const response = await api_utils_js_1.api.get(endpoint);
+        // Extract data array from response
+        let rawData = [];
+        if (parsedQuery.resource === 'instances' && response.data.instances) {
+            rawData = response.data.instances;
+        }
+        else if (parsedQuery.resource === 'hosts' && response.data.servers) {
+            rawData = response.data.servers;
+        }
+        else if (parsedQuery.resource === 'networks' && response.data.networks) {
+            rawData = response.data.networks;
+        }
+        else {
+            // Fallback: try to find array in response
+            const possibleArrays = Object.values(response.data).filter(Array.isArray);
+            if (possibleArrays.length > 0) {
+                rawData = possibleArrays[0];
+            }
+        }
+        // Apply filters
+        const filteredResults = filterResults(rawData, parsedQuery.filters);
+        // Format response based on action
+        const formattedResponse = formatResponse(parsedQuery, filteredResults, rawData.length);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(formattedResponse, null, 2)
+                }
+            ],
+            isError: false
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: "Resource query failed",
+                        message: error.message,
+                        natural_query: args?.natural_query || "unknown",
+                        suggestion: "Check VME API connectivity or try discover_capabilities first to see available resources"
+                    }, null, 2)
+                }
+            ],
+            isError: true
+        };
+    }
+}
+exports.handleQueryResources = handleQueryResources;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vme-mcp-server",
-  "version": "0.1.6",
-  "description": "VMware vCenter MCP Server - Natural language infrastructure management for Claude",
+  "version": "0.1.7",
+  "description": "",
   "main": "dist/server.js",
   "bin": {
     "vme-mcp-server": "./dist/server.js"
@@ -47,8 +47,8 @@
   },
   "devDependencies": {
     "@types/node": "^22.15.29",
+    "chai": "^5.2.0",
     "mocha": "^10.2.0",
     "nyc": "^15.1.0"
-  },
-  "description": ""
+  }
 }