vme-mcp-server 0.1.6 → 0.1.8

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,9 +3,10 @@ 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",
+    description: "Provision a new virtual machine. ⚡ TIP: Run discover_capabilities first to see available groups, zones, templates, and sizes in your environment.",
     inputSchema: {
         type: "object",
         properties: {
@@ -70,20 +71,55 @@ 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) {
+    // Resolve any node names to IDs
+    for (const assignment of nodeAssignments) {
+        if (assignment.nodeNameToResolve) {
+            // Query servers to find node with matching name
+            try {
+                const servers = await api_utils_js_1.api.get("/servers");
+                if (servers.data.servers) {
+                    const foundServer = servers.data.servers.find((server) => server.name?.toLowerCase() === assignment.nodeNameToResolve?.toLowerCase());
+                    if (foundServer) {
+                        assignment.kvmHostId = foundServer.id;
+                        delete assignment.nodeNameToResolve; // Clean up
+                    }
+                    else {
+                        // If no exact name match, log available servers for debugging
+                        const availableNames = servers.data.servers.map((s) => s.name).filter(Boolean);
+                        console.warn(`Node '${assignment.nodeNameToResolve}' not found. Available: ${availableNames.join(', ')}`);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`Failed to resolve node name '${assignment.nodeNameToResolve}':`, error);
+            }
+        }
+    }
+    // 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 +135,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 +189,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 +199,7 @@ async function handleCreateVM(args) {
                     id: groupId
                 },
                 layout: {
-                    id: 2, // Single HPE VM
+                    id: layoutId,
                     code: 'mvm-1.0-single'
                 },
                 plan: {
@@ -142,7 +214,7 @@ async function handleCreateVM(args) {
                     name: 'root',
                     size: 10,
                     storageType: 1,
-                    datastoreId: 5
+                    datastoreId: datastoreId
                 }
             ],
             networkInterfaces: [
@@ -150,7 +222,7 @@ async function handleCreateVM(args) {
                     primaryInterface: true,
                     ipMode: 'dhcp',
                     network: {
-                        id: 'network-2'
+                        id: networkId
                     },
                     networkInterfaceTypeId: 10
                 }
@@ -179,10 +251,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: "⚡ RECOMMENDED FIRST STEP: Discover VME infrastructure capabilities to learn available resources. Run this tool at least once per session to cache environment data for optimal performance with other tools.",
+    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/get-resources.js

@@ -4,7 +4,7 @@ exports.handleGetResources = exports.getResourcesTool = void 0;
 const api_utils_js_1 = require("../lib/api-utils.js");
 exports.getResourcesTool = {
     name: "get_resources",
-    description: "Discover and explore available VME infrastructure resources with intelligent filtering",
+    description: "Discover and explore available VME infrastructure resources with intelligent filtering. ⚡ TIP: Use discover_capabilities for comprehensive environment discovery first.",
     inputSchema: {
         type: "object",
         properties: {

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
 };