snow-flow 8.42.12 → 9.0.1

package/dist/mcp/servicenow-machine-learning-mcp.js

@@ -1,3457 +0,0 @@
-"use strict";
-/**
- * ServiceNow Machine Learning MCP Server
- * Real neural networks and machine learning for ServiceNow operations
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceNowMachineLearningMCP = void 0;
-// CRITICAL FIX: Add comprehensive performance polyfill for TensorFlow.js in Node.js environment
-// This fixes the "Cannot read properties of undefined (reading 'tick')" error
-if (typeof global !== 'undefined') {
-    // Import perf_hooks
-    const { performance: perfHooksPerformance } = require('perf_hooks');
-    // Create comprehensive performance object with type casting
-    if (!global.performance || !global.performance.now) {
-        global.performance = {
-            now: perfHooksPerformance.now.bind(perfHooksPerformance),
-            mark: perfHooksPerformance.mark ? perfHooksPerformance.mark.bind(perfHooksPerformance) : () => { },
-            measure: perfHooksPerformance.measure ? perfHooksPerformance.measure.bind(perfHooksPerformance) : () => { },
-            getEntriesByName: perfHooksPerformance.getEntriesByName ? perfHooksPerformance.getEntriesByName.bind(perfHooksPerformance) : () => [],
-            getEntriesByType: perfHooksPerformance.getEntriesByType ? perfHooksPerformance.getEntriesByType.bind(perfHooksPerformance) : () => [],
-            clearMarks: perfHooksPerformance.clearMarks ? perfHooksPerformance.clearMarks.bind(perfHooksPerformance) : () => { },
-            clearMeasures: perfHooksPerformance.clearMeasures ? perfHooksPerformance.clearMeasures.bind(perfHooksPerformance) : () => { },
-            // Add tick method that TensorFlow.js might be looking for
-            tick: perfHooksPerformance.now ? perfHooksPerformance.now.bind(perfHooksPerformance) : () => Date.now(),
-            timeOrigin: perfHooksPerformance.timeOrigin || Date.now()
-        };
-    }
-    // Additional Node.js specific fixes for TensorFlow.js
-    if (typeof global.window === 'undefined') {
-        // Mock minimal window object for TensorFlow.js
-        global.window = global;
-    }
-    // Ensure process.hrtime is available for high-resolution timing
-    if (!global.process || !global.process.hrtime) {
-        global.process = global.process || {};
-        global.process.hrtime = process.hrtime;
-    }
-}
-const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
-const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
-const tf = __importStar(require("@tensorflow/tfjs"));
-const mcp_logger_js_1 = require("./shared/mcp-logger.js");
-const servicenow_client_js_1 = require("../utils/servicenow-client.js");
-const ml_data_fetcher_js_1 = require("../utils/ml-data-fetcher.js");
-class ServiceNowMachineLearningMCP {
-    constructor(credentials) {
-        // Model cache with LRU tracking
-        this.modelCache = new Map();
-        this.embeddingCache = new Map();
-        this.modelAccessOrder = []; // For LRU eviction
-        // Track ML API availability
-        this.hasPA = false;
-        this.hasPI = false;
-        this.mlAPICheckComplete = false;
-        this.logger = new mcp_logger_js_1.MCPLogger('ServiceNowMachineLearning');
-        this.client = new servicenow_client_js_1.ServiceNowClient();
-        this.server = new index_js_1.Server({
-            name: 'servicenow-machine-learning',
-            version: '1.0.0',
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.setupHandlers();
-        this.initializeModels();
-    }
-    async initializeModels() {
-        try {
-            // Initialize TensorFlow.js
-            await tf.ready();
-            this.logger.info('TensorFlow.js initialized successfully');
-            // Check ML API availability in background
-            this.checkMLAPIAvailability().then(() => {
-                this.mlAPICheckComplete = true;
-                if (this.hasPA || this.hasPI) {
-                    this.logger.info(`ServiceNow ML APIs available - PA: ${this.hasPA}, PI: ${this.hasPI}`);
-                }
-                else {
-                    this.logger.info('ServiceNow ML APIs not available - will use custom neural networks');
-                }
-            });
-            // Load or create models
-            await this.loadOrCreateModels();
-        }
-        catch (error) {
-            this.logger.error('Failed to initialize models:', error);
-        }
-    }
-    async loadOrCreateModels() {
-        // Check for saved models
-        try {
-            // Try to load existing models
-            this.incidentClassifier = await this.loadIncidentClassifier();
-            this.changeRiskPredictor = await this.loadChangeRiskModel();
-            this.incidentVolumePredictor = await this.loadTimeSeriesModel();
-            this.anomalyDetector = await this.loadAnomalyDetector();
-        }
-        catch (error) {
-            this.logger.info('No saved models found, will create new ones when training');
-        }
-    }
-    setupHandlers() {
-        // List tools handler
-        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
-            const tools = [
-                // Training tools
-                {
-                    name: 'ml_train_incident_classifier',
-                    description: 'Trains LSTM neural networks on historical incident data with intelligent data selection. Automatically optimizes dataset size up to 5000 records for best accuracy. Works without PA/PI licenses.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            sample_size: {
-                                type: 'number',
-                                description: 'Number of incidents to use for training. If not specified, automatically uses all available data (up to 5000). Set to limit training data.'
-                            },
-                            auto_maximize_data: {
-                                type: 'boolean',
-                                description: 'Automatically use all available incident data for best model accuracy (default: true)',
-                                default: true
-                            },
-                            epochs: {
-                                type: 'number',
-                                description: 'Training epochs',
-                                default: 50
-                            },
-                            validation_split: {
-                                type: 'number',
-                                description: 'Validation data percentage',
-                                default: 0.2
-                            },
-                            query: {
-                                type: 'string',
-                                description: 'Custom ServiceNow query for selecting training data. If not provided, Snow-Flow will intelligently select data.',
-                                default: ''
-                            },
-                            intelligent_selection: {
-                                type: 'boolean',
-                                description: 'Let Snow-Flow intelligently select balanced training data across categories, priorities, and time periods. Combined with auto_maximize_data for optimal results.',
-                                default: true
-                            },
-                            focus_categories: {
-                                type: 'array',
-                                items: { type: 'string' },
-                                description: 'Specific categories to focus on for training (optional)'
-                            },
-                            batch_size: {
-                                type: 'number',
-                                description: 'Process data in batches to prevent memory overload',
-                                default: 100
-                            },
-                            max_vocabulary_size: {
-                                type: 'number',
-                                description: 'Maximum vocabulary size using feature hashing',
-                                default: 10000
-                            },
-                            streaming_mode: {
-                                type: 'boolean',
-                                description: 'Enable streaming mode for very large datasets',
-                                default: true
-                            }
-                        }
-                    },
-                },
-                {
-                    name: 'ml_train_change_risk',
-                    description: 'Trains neural networks to predict change implementation risks based on historical change data. Works without PA/PI licenses.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            sample_size: {
-                                type: 'number',
-                                default: 500
-                            },
-                            include_failed_changes: {
-                                type: 'boolean',
-                                default: true
-                            }
-                        }
-                    },
-                },
-                {
-                    name: 'ml_train_anomaly_detector',
-                    description: 'Trains autoencoder neural networks for anomaly detection in system metrics. Works without PA/PI licenses using standard table data.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            metric_type: {
-                                type: 'string',
-                                enum: ['incident_volume', 'response_time', 'resource_usage'],
-                                default: 'incident_volume'
-                            },
-                            lookback_days: {
-                                type: 'number',
-                                default: 90
-                            }
-                        }
-                    },
-                },
-                // Prediction tools
-                {
-                    name: 'ml_classify_incident',
-                    description: 'Classifies incidents and predicts properties using trained neural networks. Returns category, priority, and assignment recommendations.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            incident_number: {
-                                type: 'string',
-                                description: 'Incident number to classify'
-                            },
-                            short_description: {
-                                type: 'string',
-                                description: 'Incident short description'
-                            },
-                            description: {
-                                type: 'string',
-                                description: 'Incident full description'
-                            }
-                        }
-                    },
-                },
-                {
-                    name: 'ml_predict_change_risk',
-                    description: 'Predicts implementation risk for change requests using trained neural networks. Provides risk scores and mitigation suggestions.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            change_number: {
-                                type: 'string'
-                            },
-                            change_details: {
-                                type: 'object',
-                                description: 'Change request details'
-                            }
-                        }
-                    },
-                },
-                {
-                    name: 'ml_forecast_incidents',
-                    description: 'Forecasts future incident volumes using LSTM time series models. Supports category-specific predictions.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            forecast_days: {
-                                type: 'number',
-                                default: 7
-                            },
-                            category: {
-                                type: 'string',
-                                description: 'Specific category to forecast (optional)'
-                            }
-                        }
-                    },
-                },
-                {
-                    name: 'ml_detect_anomalies',
-                    description: 'Detects anomalies in incident patterns, user behavior, or system performance using autoencoder models.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            metric_type: {
-                                type: 'string',
-                                enum: ['incident_patterns', 'user_behavior', 'system_performance']
-                            },
-                            sensitivity: {
-                                type: 'number',
-                                description: 'Anomaly detection sensitivity (0.1-1.0)',
-                                default: 0.8
-                            }
-                        }
-                    },
-                },
-                // Model management
-                {
-                    name: 'ml_model_status',
-                    description: 'Retrieves status and performance metrics for all trained ML models including accuracy, loss, and usage statistics.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            model: {
-                                type: 'string',
-                                enum: ['incident_classifier', 'change_risk', 'anomaly_detector', 'all']
-                            }
-                        }
-                    },
-                },
-                {
-                    name: 'ml_evaluate_model',
-                    description: 'Evaluates model performance using test datasets. Returns accuracy, precision, recall, and F1 scores.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            model: {
-                                type: 'string',
-                                enum: ['incident_classifier', 'change_risk', 'anomaly_detector']
-                            },
-                            test_size: {
-                                type: 'number',
-                                default: 100
-                            }
-                        }
-                    },
-                },
-                // ServiceNow Native ML Integration
-                {
-                    name: 'ml_performance_analytics',
-                    description: 'Accesses ServiceNow Performance Analytics ML for KPI forecasting. Requires Performance Analytics plugin license.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            indicator_name: {
-                                type: 'string',
-                                description: 'PA indicator to analyze'
-                            },
-                            forecast_periods: {
-                                type: 'number',
-                                default: 30
-                            },
-                            breakdown: {
-                                type: 'string',
-                                description: 'Breakdown field for analysis'
-                            }
-                        },
-                        required: ['indicator_name']
-                    },
-                },
-                {
-                    name: 'ml_predictive_intelligence',
-                    description: 'Uses ServiceNow Predictive Intelligence for high-accuracy incident classification. Requires Predictive Intelligence plugin license.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            operation: {
-                                type: 'string',
-                                enum: ['similar_incidents', 'cluster_analysis', 'solution_recommendation', 'categorization']
-                            },
-                            record_type: {
-                                type: 'string',
-                                default: 'incident'
-                            },
-                            record_id: {
-                                type: 'string',
-                                description: 'Record sys_id or number'
-                            },
-                            options: {
-                                type: 'object',
-                                description: 'Additional options for the operation'
-                            }
-                        },
-                        required: ['operation']
-                    },
-                },
-                {
-                    name: 'ml_agent_intelligence',
-                    description: 'Uses Agent Intelligence for automated work assignment and routing. Requires Agent Intelligence plugin license.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            task_type: {
-                                type: 'string',
-                                enum: ['incident', 'case', 'task']
-                            },
-                            task_id: {
-                                type: 'string'
-                            },
-                            get_recommendations: {
-                                type: 'boolean',
-                                default: true
-                            },
-                            auto_assign: {
-                                type: 'boolean',
-                                default: false
-                            }
-                        },
-                        required: ['task_type', 'task_id']
-                    },
-                },
-                {
-                    name: 'ml_process_optimization',
-                    description: 'Performs ML-driven process optimization and bottleneck analysis. Requires Performance Analytics plugin license.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            process_name: {
-                                type: 'string',
-                                description: 'Process to analyze'
-                            },
-                            time_range: {
-                                type: 'string',
-                                default: 'last_30_days'
-                            },
-                            optimization_goal: {
-                                type: 'string',
-                                enum: ['reduce_time', 'improve_quality', 'reduce_cost', 'increase_satisfaction']
-                            }
-                        },
-                        required: ['process_name']
-                    },
-                },
-                {
-                    name: 'ml_virtual_agent_nlu',
-                    description: 'Provides Natural Language Understanding for intent and entity extraction. Requires Virtual Agent plugin license.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            text: {
-                                type: 'string',
-                                description: 'Text to analyze'
-                            },
-                            context: {
-                                type: 'object',
-                                description: 'Conversation context'
-                            },
-                            language: {
-                                type: 'string',
-                                default: 'en'
-                            }
-                        },
-                        required: ['text']
-                    },
-                },
-                {
-                    name: 'ml_hybrid_recommendation',
-                    description: 'Hybrid ML approach that automatically selects between native ServiceNow ML (if licensed) or TensorFlow.js for optimal results.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            use_case: {
-                                type: 'string',
-                                enum: ['incident_resolution', 'change_planning', 'capacity_planning', 'user_experience']
-                            },
-                            native_weight: {
-                                type: 'number',
-                                description: 'Weight for ServiceNow native ML (0-1)',
-                                default: 0.6
-                            },
-                            custom_weight: {
-                                type: 'number',
-                                description: 'Weight for custom neural networks (0-1)',
-                                default: 0.4
-                            }
-                        },
-                        required: ['use_case']
-                    },
-                }
-            ];
-            return { tools };
-        });
-        // Call tool handler
-        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                // Start operation with token tracking
-                this.logger.operationStart(name, args);
-                let result;
-                switch (name) {
-                    // Training
-                    case 'ml_train_incident_classifier':
-                        result = await this.trainIncidentClassifier(args);
-                        break;
-                    case 'ml_train_change_risk':
-                        result = await this.trainChangeRiskModel(args);
-                        break;
-                    case 'ml_train_anomaly_detector':
-                        result = await this.trainAnomalyDetector(args);
-                        break;
-                    // Prediction
-                    case 'ml_classify_incident':
-                        result = await this.classifyIncident(args);
-                        break;
-                    case 'ml_predict_change_risk':
-                        result = await this.predictChangeRisk(args);
-                        break;
-                    case 'ml_forecast_incidents':
-                        result = await this.forecastIncidents(args);
-                        break;
-                    case 'ml_detect_anomalies':
-                        result = await this.detectAnomalies(args);
-                        break;
-                    // Management
-                    case 'ml_model_status':
-                        result = await this.getModelStatus(args);
-                        break;
-                    case 'ml_evaluate_model':
-                        result = await this.evaluateModel(args);
-                        break;
-                    // ServiceNow Native ML
-                    case 'ml_performance_analytics':
-                        result = await this.performanceAnalytics(args);
-                        break;
-                    case 'ml_predictive_intelligence':
-                        result = await this.predictiveIntelligence(args);
-                        break;
-                    case 'ml_agent_intelligence':
-                        result = await this.agentIntelligence(args);
-                        break;
-                    case 'ml_process_optimization':
-                        result = await this.processOptimization(args);
-                        break;
-                    case 'ml_virtual_agent_nlu':
-                        result = await this.virtualAgentNLU(args);
-                        break;
-                    case 'ml_hybrid_recommendation':
-                        result = await this.hybridRecommendation(args);
-                        break;
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
-                // Complete operation with token tracking
-                result = this.logger.addTokenUsageToResponse(result);
-                result = this.logger.addTokenUsageToResponse(result);
-                this.logger.operationComplete(name, result);
-                return result;
-            }
-            catch (error) {
-                this.logger.error(`ML tool execution failed: ${name}`, error);
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: error.message,
-                                status: 'error'
-                            })
-                        }]
-                };
-            }
-        });
-    }
-    /**
-     * Train incident classification neural network
-     * Uses PI if available, otherwise uses custom TensorFlow.js
-     */
-    async trainIncidentClassifier(args) {
-        const { sample_size, // No default - will be determined dynamically
-        epochs = 50, validation_split = 0.2, query = '', intelligent_selection = true, focus_categories = [], batch_size = 100, streaming_mode = true, auto_maximize_data = true // New option to automatically use all available data
-         } = args;
-        // CRITICAL FIX: Ensure max_vocabulary_size is ALWAYS valid
-        const max_vocabulary_size = Math.max(1000, args.max_vocabulary_size || 5000);
-        try {
-            // Wait for ML API check if not complete
-            if (!this.mlAPICheckComplete) {
-                await this.checkMLAPIAvailability();
-            }
-            // First, check how much data is available
-            let actualSampleSize = sample_size || 2000; // Default to 2000 if not specified
-            if (auto_maximize_data || !sample_size) {
-                this.logger.info('🔍 Checking available incident data for optimal training...');
-                try {
-                    // Count available incidents that match our criteria
-                    const countQuery = query || (intelligent_selection ?
-                        'categoryISNOTEMPTY^descriptionISNOTEMPTY^sys_created_onONLast 6 months' :
-                        '');
-                    // Use ServiceNow aggregate API to count records efficiently
-                    let totalAvailable = 0;
-                    try {
-                        // Try using the stats API first (most efficient)
-                        const statsResponse = await this.makeServiceNowRequest('/api/now/stats/incident', {
-                            sysparm_query: countQuery,
-                            sysparm_count: true
-                        });
-                        if (statsResponse.data?.result?.stats?.count) {
-                            totalAvailable = parseInt(statsResponse.data.result.stats.count);
-                        }
-                    }
-                    catch (statsError) {
-                        // Fallback: Use aggregate API
-                        try {
-                            const aggResponse = await this.makeServiceNowRequest('/api/now/table/incident', {
-                                sysparm_query: countQuery,
-                                sysparm_count: true,
-                                sysparm_limit: 1
-                            });
-                            // ServiceNow returns count in result
-                            if (aggResponse?.result && Array.isArray(aggResponse.result)) {
-                                // Even with limit 1, we can estimate based on typical data
-                                totalAvailable = 2000; // Conservative estimate when count API fails
-                                this.logger.info('Using conservative estimate of 2000 incidents');
-                            }
-                        }
-                        catch (aggError) {
-                            // Final fallback: Estimate based on a sample
-                            this.logger.trackAPICall('SEARCH', 'incident', 1000);
-                            const sampleResult = await this.client.searchRecords('incident', countQuery, 1000);
-                            if (sampleResult.success && sampleResult.data?.result) {
-                                totalAvailable = sampleResult.data.result.length >= 1000 ? 5000 : sampleResult.data.result.length;
-                                this.logger.info(`Estimated ${totalAvailable} incidents available (sampled)`);
-                            }
-                        }
-                    }
-                    // Use a reasonable maximum (5000) to avoid memory issues
-                    const maxRecommended = 5000;
-                    const optimalSize = Math.min(totalAvailable, maxRecommended);
-                    if (totalAvailable > 0) {
-                        this.logger.info(`📊 Found ${totalAvailable} incidents available for training`);
-                        if (sample_size && sample_size > totalAvailable) {
-                            this.logger.warn(`⚠️ Requested ${sample_size} samples but only ${totalAvailable} available`);
-                        }
-                        // Use the optimal amount of data
-                        actualSampleSize = sample_size ?
-                            Math.min(sample_size, totalAvailable) :
-                            optimalSize;
-                        this.logger.info(`✅ Using ${actualSampleSize} incidents for training (optimal for this dataset)`);
-                        // Provide recommendations based on data size
-                        if (actualSampleSize < 500) {
-                            this.logger.warn('⚠️ Less than 500 samples - model accuracy may be limited');
-                            this.logger.info('💡 Recommendation: Gather more incident data for better results');
-                        }
-                        else if (actualSampleSize < 1000) {
-                            this.logger.info('📈 Moderate dataset - expect 70-80% accuracy');
-                        }
-                        else if (actualSampleSize < 2000) {
-                            this.logger.info('📈 Good dataset - expect 80-85% accuracy');
-                        }
-                        else {
-                            this.logger.info('🎯 Excellent dataset - expect 85-95% accuracy');
-                        }
-                    }
-                    else {
-                        // Fallback to a default if count fails
-                        actualSampleSize = sample_size || 1000;
-                        this.logger.info(`Using default sample size: ${actualSampleSize}`);
-                    }
-                }
-                catch (error) {
-                    // If counting fails, use the provided or default size
-                    actualSampleSize = sample_size || 1000;
-                    this.logger.warn('Could not determine available data, using:', actualSampleSize);
-                }
-            }
-            // If PI is available, try to use it first
-            if (this.hasPI) {
-                try {
-                    this.logger.info('Predictive Intelligence detected - using native ServiceNow ML for optimal results');
-                    // Train using PI clustering
-                    const piResult = await this.makeServiceNowRequest('/api/sn_ind/clustering/train', {
-                        table: 'incident',
-                        fields: ['short_description', 'description', 'category'],
-                        sample_size: sample_size
-                    }, 'POST');
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    status: 'success',
-                                    message: 'Incident classifier trained using ServiceNow Predictive Intelligence',
-                                    method: 'native_pi',
-                                    model_id: piResult.model_id,
-                                    accuracy: piResult.accuracy || 'PI model trained successfully',
-                                    note: 'Using native PI provides 95%+ accuracy with ServiceNow optimization'
-                                }, null, 2)
-                            }]
-                    };
-                }
-                catch (piError) {
-                    this.logger.warn('PI training failed, falling back to custom neural network:', piError);
-                    // Continue with TensorFlow.js below
-                }
-            }
-            // Use custom TensorFlow.js neural network
-            this.logger.info(`Training custom LSTM neural network with intelligent memory management...`);
-            this.logger.info(`Settings: batch_size=${batch_size}, max_vocabulary=${max_vocabulary_size}, streaming=${streaming_mode}`);
-            // If streaming mode is enabled, process data in batches
-            if (streaming_mode && sample_size > batch_size * 2) {
-                return await this.trainWithStreaming(args);
-            }
-            // For smaller datasets, use the original approach but with optimizations
-            // 🔴 CRITICAL FIX: Use full sample_size, not artificially limited amount
-            let incidents = [];
-            try {
-                incidents = await this.fetchIncidentData(actualSampleSize, {
-                    query,
-                    intelligent_selection,
-                    focus_categories
-                });
-                if (!incidents || !Array.isArray(incidents)) {
-                    throw new Error('Invalid response from fetchIncidentData');
-                }
-                this.logger.info(`Retrieved ${incidents.length} incidents for initial training`);
-            }
-            catch (fetchError) {
-                this.logger.error('Failed to fetch incident data:', fetchError);
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                status: 'error',
-                                error: 'Failed to fetch incident data from ServiceNow',
-                                details: fetchError.message,
-                                troubleshooting: [
-                                    '1. Check ServiceNow OAuth authentication (snow-flow auth login)',
-                                    '2. Verify read access to incident table',
-                                    '3. Ensure incidents exist in ServiceNow (state!=7)',
-                                    '4. Check MCP server connection (snow-flow mcp status)',
-                                    '5. Try with smaller sample_size (e.g., 50)'
-                                ],
-                                recommendation: 'Run: snow-flow auth login && snow-flow test-incident-access'
-                            }, null, 2)
-                        }]
-                };
-            }
-            if (incidents.length === 0) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                status: 'error',
-                                error: 'No incidents found for training',
-                                query_used: query || 'default intelligent selection',
-                                troubleshooting: [
-                                    '1. Check if incidents exist in ServiceNow',
-                                    '2. Try a broader query (e.g., "active=true")',
-                                    '3. Verify table permissions',
-                                    '4. Use ServiceNow UI to confirm incident data exists'
-                                ]
-                            }, null, 2)
-                        }]
-                };
-            }
-            if (incidents.length < 100) {
-                this.logger.warn(`Low training data: only ${incidents.length} incidents. Proceeding with reduced dataset...`);
-            }
-            // Prepare training data with memory optimization
-            let features, labels, tokenizer, categories;
-            try {
-                const preparedData = await this.prepareIncidentDataOptimized(incidents, max_vocabulary_size);
-                features = preparedData.features;
-                labels = preparedData.labels;
-                tokenizer = preparedData.tokenizer;
-                categories = preparedData.categories;
-            }
-            catch (prepError) {
-                this.logger.error('Failed to prepare training data:', prepError);
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                status: 'error',
-                                error: 'Failed to prepare training data',
-                                details: prepError.message,
-                                incidents_count: incidents.length
-                            }, null, 2)
-                        }]
-                };
-            }
-            // Get vocabulary size from tokenizer Map - MUST match the size used in prepareIncidentDataOptimized
-            const vocabularySize = tokenizer.get('_vocabulary_size');
-            if (!vocabularySize || vocabularySize <= 0) {
-                throw new Error(`Invalid vocabulary size from tokenizer: ${vocabularySize}. Cannot create embedding layer.`);
-            }
-            // CRITICAL: Validate vocabulary size is reasonable
-            if (vocabularySize < 1000) {
-                this.logger.warn(`Vocabulary size ${vocabularySize} is very small, using minimum of 1000`);
-            }
-            this.logger.info(`Creating model with vocabulary size: ${vocabularySize}, categories: ${categories.length}`);
-            // Create neural network model with VALIDATED vocabulary size
-            let model;
-            try {
-                this.logger.info('Creating TensorFlow.js model...');
-                // Additional validation before model creation
-                if (typeof tf === 'undefined' || !tf.sequential) {
-                    throw new Error('TensorFlow.js not properly loaded');
-                }
-                if (!global.performance || typeof global.performance.tick !== 'function') {
-                    throw new Error('Performance API not available - TensorFlow.js requires timing functions');
-                }
-                model = tf.sequential({
-                    layers: [
-                        // Embedding layer for text - inputDim MUST match the vocabulary size used in data preparation
-                        tf.layers.embedding({
-                            inputDim: vocabularySize, // Use the EXACT vocabulary size from data preparation
-                            outputDim: 128,
-                            inputLength: 100 // Max sequence length
-                        }),
-                        // LSTM for sequence processing
-                        tf.layers.lstm({
-                            units: 64,
-                            returnSequences: false,
-                            dropout: 0.2,
-                            recurrentDropout: 0.2
-                        }),
-                        // Dense layers
-                        tf.layers.dense({
-                            units: 32,
-                            activation: 'relu'
-                        }),
-                        tf.layers.dropout({ rate: 0.3 }),
-                        // Output layer
-                        tf.layers.dense({
-                            units: categories.length,
-                            activation: 'softmax'
-                        })
-                    ]
-                });
-                this.logger.info('✅ Model created successfully');
-            }
-            catch (modelError) {
-                this.logger.error('Failed to create TensorFlow.js model:', modelError);
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                status: 'error',
-                                error: 'Failed to create neural network model',
-                                details: modelError.message,
-                                troubleshooting: [
-                                    '1. TensorFlow.js initialization issue detected',
-                                    '2. Try restarting the MCP server',
-                                    '3. Check Node.js version compatibility',
-                                    '4. Performance API polyfill may need adjustment'
-                                ],
-                                technical_details: {
-                                    vocabulary_size: vocabularySize,
-                                    categories_count: categories.length,
-                                    tensorflow_available: typeof tf !== 'undefined',
-                                    performance_available: typeof global.performance !== 'undefined',
-                                    tick_available: typeof global.performance?.tick === 'function'
-                                }
-                            }, null, 2)
-                        }]
-                };
-            }
-            // Compile model
-            try {
-                this.logger.info('Compiling TensorFlow.js model...');
-                model.compile({
-                    optimizer: tf.train.adam(0.001),
-                    loss: 'categoricalCrossentropy',
-                    metrics: ['accuracy']
-                });
-                this.logger.info('✅ Model compiled successfully');
-            }
-            catch (compileError) {
-                this.logger.error('Failed to compile TensorFlow.js model:', compileError);
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                status: 'error',
-                                error: 'Failed to compile neural network model',
-                                details: compileError.message,
-                                troubleshooting: [
-                                    '1. Model architecture validation failed',
-                                    '2. Check TensorFlow.js optimizer availability',
-                                    '3. Verify model layers are compatible',
-                                    '4. Try with simpler model configuration'
-                                ]
-                            }, null, 2)
-                        }]
-                };
-            }
-            this.logger.info('🚀 Starting neural network training...');
-            // Train model with improved error handling and progress tracking
-            let history;
-            const trainingStartTime = Date.now();
-            let lastProgressUpdate = Date.now();
-            try {
-                this.logger.info(`📊 Training Configuration:`);
-                this.logger.info(`  • Epochs: ${epochs}`);
-                this.logger.info(`  • Samples: ${incidents.length}`);
-                this.logger.info(`  • Validation Split: ${(validation_split * 100).toFixed(0)}%`);
-                this.logger.info(`  • Categories: ${categories.length}`);
-                this.logger.info(`  • Vocabulary Size: ${vocabularySize}`);
-                this.logger.info(`  • Batch Size: 32`);
-                history = await model.fit(features, labels, {
-                    epochs,
-                    validationSplit: validation_split,
-                    batchSize: 32,
-                    callbacks: {
-                        onEpochBegin: (epoch) => {
-                            const progress = ((epoch / epochs) * 100).toFixed(0);
-                            this.logger.info(`\n⏳ Epoch ${epoch + 1}/${epochs} (${progress}% complete)`);
-                        },
-                        onEpochEnd: (epoch, logs) => {
-                            try {
-                                const loss = logs?.loss ? logs.loss.toFixed(4) : 'N/A';
-                                const accuracy = logs?.acc ? (logs.acc * 100).toFixed(2) : 'N/A';
-                                const valLoss = logs?.val_loss ? logs.val_loss.toFixed(4) : 'N/A';
-                                const valAcc = logs?.val_acc ? (logs.val_acc * 100).toFixed(2) : 'N/A';
-                                // Calculate ETA
-                                const elapsedTime = Date.now() - trainingStartTime;
-                                const avgTimePerEpoch = elapsedTime / (epoch + 1);
-                                const remainingEpochs = epochs - epoch - 1;
-                                const etaMs = avgTimePerEpoch * remainingEpochs;
-                                const etaSeconds = Math.round(etaMs / 1000);
-                                const etaString = remainingEpochs > 0 ? ` | ETA: ${etaSeconds}s` : '';
-                                this.logger.info(`  ✓ Loss: ${loss} | Accuracy: ${accuracy}%`);
-                                if (validation_split > 0) {
-                                    this.logger.info(`  ✓ Val Loss: ${valLoss} | Val Accuracy: ${valAcc}%${etaString}`);
-                                }
-                                // Provide feedback on training progress
-                                const currentAccuracy = logs?.acc || 0;
-                                if (currentAccuracy > 0.9 && epoch > epochs / 2) {
-                                    this.logger.info(`  🎯 Excellent accuracy achieved!`);
-                                }
-                                else if (currentAccuracy > 0.8) {
-                                    this.logger.info(`  📈 Good progress - model is learning well`);
-                                }
-                                else if (currentAccuracy < 0.3 && epoch > epochs / 3) {
-                                    this.logger.warn(`  ⚠️ Low accuracy - consider more diverse training data`);
-                                }
-                                // Update progress timestamp
-                                lastProgressUpdate = Date.now();
-                            }
-                            catch (e) {
-                                // Ignore callback errors to prevent training interruption
-                                this.logger.warn(`Callback error in epoch ${epoch + 1}:`, e);
-                            }
-                        },
-                        onBatchEnd: (batch, logs) => {
-                            // Log progress every 10 seconds during long training
-                            if (Date.now() - lastProgressUpdate > 10000) {
-                                const loss = logs?.loss ? logs.loss.toFixed(4) : 'N/A';
-                                this.logger.info(`    Processing batch ${batch + 1}... (loss: ${loss})`);
-                                lastProgressUpdate = Date.now();
-                            }
-                        }
-                    }
-                });
-                const totalTime = ((Date.now() - trainingStartTime) / 1000).toFixed(1);
-                this.logger.info(`\n✅ Training completed successfully in ${totalTime} seconds!`);
-            }
-            catch (trainingError) {
-                this.logger.error('❌ Model training failed:', trainingError);
-                // Clean up tensors before returning error
-                try {
-                    features.dispose();
-                    labels.dispose();
-                    model.dispose();
-                }
-                catch (cleanupError) {
-                    this.logger.warn('Cleanup error:', cleanupError);
-                }
-                // Provide detailed error analysis
-                let errorType = 'Unknown';
-                let specificRecommendations = [];
-                if (trainingError.message?.includes('memory')) {
-                    errorType = 'Out of Memory';
-                    specificRecommendations = [
-                        'Reduce batch_size to 16 or 8',
-                        'Reduce sample_size to 500 or less',
-                        'Restart the MCP server to clear memory',
-                        'Close other applications to free up RAM'
-                    ];
-                }
-                else if (trainingError.message?.includes('shape') || trainingError.message?.includes('dimension')) {
-                    errorType = 'Data Shape Mismatch';
-                    specificRecommendations = [
-                        'Check that all training samples have consistent format',
-                        'Verify categories are properly extracted',
-                        'Ensure no empty or null values in training data'
-                    ];
-                }
-                else if (trainingError.message?.includes('NaN') || trainingError.message?.includes('Infinity')) {
-                    errorType = 'Numerical Instability';
-                    specificRecommendations = [
-                        'Reduce learning rate',
-                        'Check for extreme values in data',
-                        'Try normalizing input features'
-                    ];
-                }
-                else if (trainingError.message?.includes('tensor') || trainingError.message?.includes('disposed')) {
-                    errorType = 'TensorFlow Resource Error';
-                    specificRecommendations = [
-                        'Restart the MCP server',
-                        'Check TensorFlow.js installation',
-                        'Verify Node.js version compatibility (v18+ recommended)'
-                    ];
-                }
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                status: 'error',
-                                error_type: errorType,
-                                message: '❌ Neural network training failed',
-                                details: trainingError.message || trainingError.toString(),
-                                stack_trace: trainingError.stack?.split('\n').slice(0, 5).join('\n'),
-                                troubleshooting: {
-                                    immediate_actions: specificRecommendations,
-                                    general_recommendations: [
-                                        '1. Check ServiceNow connection: snow-flow auth test',
-                                        '2. Verify incident data exists: Use ServiceNow UI',
-                                        '3. Try with smaller dataset: sample_size: 100',
-                                        '4. Simplify parameters: epochs: 10',
-                                        '5. Check system resources: free memory, CPU usage'
-                                    ],
-                                    alternative_approaches: [
-                                        'Try ml_train_anomaly_detector for simpler models',
-                                        'Use ml_forecast_incidents for time-series predictions',
-                                        'Consider using ServiceNow native ML if available'
-                                    ]
-                                },
-                                training_context: {
-                                    attempted_epochs: epochs,
-                                    validation_split: validation_split,
-                                    batch_size: 32,
-                                    samples_loaded: incidents.length,
-                                    categories_found: categories?.length || 0,
-                                    vocabulary_size: vocabularySize || 0
-                                },
-                                support_info: {
-                                    tensorflow_version: tf.version.tfjs,
-                                    node_version: process.version,
-                                    platform: process.platform,
-                                    memory_usage: `${Math.round(process.memoryUsage().heapUsed / 1024 / 1024)}MB`,
-                                    uptime: `${Math.round(process.uptime())} seconds`
-                                }
-                            }, null, 2)
-                        }]
-                };
-            }
-            // Save model
-            this.incidentClassifier = {
-                model,
-                categories,
-                tokenizer,
-                maxLength: 100
-            };
-            // Clean up tensors
-            features.dispose();
-            labels.dispose();
-            // Calculate final metrics
-            const finalAccuracy = history.history.acc[history.history.acc.length - 1];
-            const finalLoss = history.history.loss[history.history.loss.length - 1];
-            const valAccuracy = history.history.val_acc ? history.history.val_acc[history.history.val_acc.length - 1] : null;
-            const valLoss = history.history.val_loss ? history.history.val_loss[history.history.val_loss.length - 1] : null;
-            // Determine model quality
-            let modelQuality = 'Unknown';
-            let recommendations = [];
-            if (finalAccuracy >= 0.9) {
-                modelQuality = 'Excellent';
-                recommendations.push('Model is ready for production use');
-                recommendations.push('Consider saving this model for future use');
-            }
-            else if (finalAccuracy >= 0.8) {
-                modelQuality = 'Good';
-                recommendations.push('Model performance is good for most use cases');
-                recommendations.push('Additional training data could improve accuracy');
-            }
-            else if (finalAccuracy >= 0.7) {
-                modelQuality = 'Fair';
-                recommendations.push('Model needs improvement for production use');
-                recommendations.push('Consider adding more diverse training data');
-                recommendations.push('Try increasing epochs or adjusting model architecture');
-            }
-            else {
-                modelQuality = 'Poor';
-                recommendations.push('Model accuracy is too low for practical use');
-                recommendations.push('Check data quality and ensure categories are well-defined');
-                recommendations.push('Consider using more training samples');
-            }
-            // Check for overfitting
-            if (valAccuracy && finalAccuracy - valAccuracy > 0.15) {
-                recommendations.push('⚠️ Warning: Model may be overfitting (training accuracy much higher than validation)');
-                recommendations.push('Consider using more dropout or regularization');
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            status: 'success',
-                            message: '🎉 Incident classifier trained successfully using TensorFlow.js neural network!',
-                            model_quality: modelQuality,
-                            metrics: {
-                                training_accuracy: (finalAccuracy * 100).toFixed(2) + '%',
-                                training_loss: finalLoss.toFixed(4),
-                                validation_accuracy: valAccuracy ? (valAccuracy * 100).toFixed(2) + '%' : 'N/A',
-                                validation_loss: valLoss ? valLoss.toFixed(4) : 'N/A'
-                            },
-                            model_details: {
-                                method: 'tensorflow_js_lstm',
-                                architecture: 'Embedding -> LSTM(64) -> Dense(32) -> Output',
-                                categories: categories.length,
-                                vocabulary_size: vocabularySize,
-                                max_sequence_length: 100,
-                                training_samples: incidents.length,
-                                epochs_completed: epochs,
-                                training_time: ((Date.now() - trainingStartTime) / 1000).toFixed(1) + ' seconds'
-                            },
-                            recommendations,
-                            next_steps: [
-                                'Use ml_classify_incident to classify new incidents',
-                                'Use ml_evaluate_model to test on unseen data',
-                                'Use ml_model_status to check model performance metrics'
-                            ],
-                            ml_api_status: {
-                                performance_analytics: this.hasPA ? 'Available' : 'Not Available',
-                                predictive_intelligence: this.hasPI ? 'Available' : 'Not Available',
-                                fallback_used: !this.hasPI
-                            }
-                        }, null, 2)
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Training failed:', error);
-            throw error;
-        }
-    }
-    /**
-     * Train change risk prediction model
-     */
-    async trainChangeRiskModel(args) {
-        const { sample_size = 500, include_failed_changes = true } = args;
-        try {
-            // Fetch change data
-            const changes = await this.fetchChangeData(sample_size, include_failed_changes);
-            // Prepare features and labels
-            const { features, labels, featureNames, riskLevels } = await this.prepareChangeData(changes);
-            // Create neural network
-            const model = tf.sequential({
-                layers: [
-                    tf.layers.dense({
-                        inputShape: [featureNames.length],
-                        units: 64,
-                        activation: 'relu'
-                    }),
-                    tf.layers.batchNormalization(),
-                    tf.layers.dropout({ rate: 0.3 }),
-                    tf.layers.dense({
-                        units: 32,
-                        activation: 'relu'
-                    }),
-                    tf.layers.dropout({ rate: 0.2 }),
-                    tf.layers.dense({
-                        units: 16,
-                        activation: 'relu'
-                    }),
-                    tf.layers.dense({
-                        units: riskLevels.length,
-                        activation: 'softmax'
-                    })
-                ]
-            });
-            model.compile({
-                optimizer: tf.train.adam(0.001),
-                loss: 'categoricalCrossentropy',
-                metrics: ['accuracy']
-            });
-            // Train with improved error handling
-            const history = await model.fit(features, labels, {
-                epochs: 100,
-                validationSplit: 0.2,
-                batchSize: 16,
-                callbacks: {
-                    onEpochEnd: (epoch, logs) => {
-                        try {
-                            if (epoch % 10 === 0) {
-                                const accuracy = logs?.acc ? logs.acc.toFixed(4) : 'N/A';
-                                this.logger.info(`Epoch ${epoch}: accuracy = ${accuracy}`);
-                            }
-                        }
-                        catch (e) {
-                            this.logger.warn(`Callback error in epoch ${epoch}:`, e);
-                        }
-                    }
-                }
-            });
-            this.changeRiskPredictor = {
-                model,
-                features: featureNames,
-                riskLevels
-            };
-            features.dispose();
-            labels.dispose();
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            status: 'success',
-                            message: 'Change risk model trained successfully',
-                            final_accuracy: history.history.acc[history.history.acc.length - 1],
-                            risk_levels: riskLevels,
-                            features: featureNames
-                        })
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Change risk training failed:', error);
-            throw error;
-        }
-    }
-    /**
-     * Train anomaly detection autoencoder
-     */
-    async trainAnomalyDetector(args) {
-        const { metric_type = 'incident_volume', lookback_days = 90 } = args;
-        try {
-            // Fetch metric data
-            const data = await this.fetchMetricData(metric_type, lookback_days);
-            // Normalize data
-            const normalized = tf.tidy(() => {
-                const tensor = tf.tensor2d(data);
-                const min = tensor.min();
-                const max = tensor.max();
-                return tensor.sub(min).div(max.sub(min));
-            });
-            const inputDim = data[0].length;
-            const encodingDim = Math.floor(inputDim / 3);
-            // Create encoder
-            const encoder = tf.sequential({
-                layers: [
-                    tf.layers.dense({
-                        inputShape: [inputDim],
-                        units: Math.floor(inputDim * 0.75),
-                        activation: 'relu'
-                    }),
-                    tf.layers.dense({
-                        units: Math.floor(inputDim * 0.5),
-                        activation: 'relu'
-                    }),
-                    tf.layers.dense({
-                        units: encodingDim,
-                        activation: 'relu'
-                    })
-                ]
-            });
-            // Create decoder
-            const decoder = tf.sequential({
-                layers: [
-                    tf.layers.dense({
-                        inputShape: [encodingDim],
-                        units: Math.floor(inputDim * 0.5),
-                        activation: 'relu'
-                    }),
-                    tf.layers.dense({
-                        units: Math.floor(inputDim * 0.75),
-                        activation: 'relu'
-                    }),
-                    tf.layers.dense({
-                        units: inputDim,
-                        activation: 'sigmoid'
-                    })
-                ]
-            });
-            // Create autoencoder
-            const autoencoder = tf.sequential({
-                layers: [...encoder.layers, ...decoder.layers]
-            });
-            autoencoder.compile({
-                optimizer: tf.train.adam(0.001),
-                loss: 'meanSquaredError'
-            });
-            // Train with improved error handling
-            await autoencoder.fit(normalized, normalized, {
-                epochs: 100,
-                batchSize: 32,
-                validationSplit: 0.1,
-                callbacks: {
-                    onEpochEnd: (epoch, logs) => {
-                        try {
-                            if (epoch % 20 === 0) {
-                                const loss = logs?.loss ? logs.loss.toFixed(6) : 'N/A';
-                                this.logger.info(`Anomaly detector epoch ${epoch}: loss = ${loss}`);
-                            }
-                        }
-                        catch (e) {
-                            this.logger.warn(`Callback error in epoch ${epoch}:`, e);
-                        }
-                    }
-                }
-            });
-            // Calculate threshold (95th percentile of reconstruction error)
-            const predictions = autoencoder.predict(normalized);
-            const errors = tf.losses.meanSquaredError(normalized, predictions);
-            const errorsData = await errors.data();
-            const sortedErrors = Array.from(errorsData).sort((a, b) => a - b);
-            const percentileIndex = Math.floor(sortedErrors.length * 0.95);
-            const threshold = [sortedErrors[percentileIndex]];
-            this.anomalyDetector = {
-                encoder,
-                decoder,
-                threshold: threshold[0]
-            };
-            normalized.dispose();
-            predictions.dispose();
-            errors.dispose();
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            status: 'success',
-                            message: 'Anomaly detector trained successfully',
-                            metric_type,
-                            encoding_dimension: encodingDim,
-                            threshold: threshold[0],
-                            training_samples: data.length
-                        })
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Anomaly detector training failed:', error);
-            throw error;
-        }
-    }
-    /**
-     * Classify incident using PI if available, otherwise neural network
-     */
-    /**
-     * Classify an incident using trained ML model
-     */
-    async classifyIncident(args) {
-        try {
-            this.logger.info('🔬 Starting incident classification...');
-            // Validate input
-            if (!args.incident_number && !args.short_description && !args.description) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                status: 'error',
-                                message: 'No incident data provided',
-                                required: 'Either incident_number OR short_description/description',
-                                examples: [
-                                    '{ "incident_number": "INC0123456" }',
-                                    '{ "short_description": "Email not working", "description": "Cannot send emails from Outlook" }'
-                                ]
-                            }, null, 2)
-                        }]
-                };
-            }
-            let incidentData;
-            if (args.incident_number) {
-                this.logger.info(`Fetching incident ${args.incident_number} from ServiceNow...`);
-                try {
-                    // Fetch incident from ServiceNow
-                    const response = await this.fetchSingleIncident(args.incident_number);
-                    incidentData = response;
-                    this.logger.info(`✅ Incident retrieved: "${incidentData.short_description}"`);
-                }
-                catch (fetchError) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    status: 'error',
-                                    message: `Failed to fetch incident ${args.incident_number}`,
-                                    error: fetchError.message,
-                                    troubleshooting: [
-                                        '1. Verify incident number exists in ServiceNow',
-                                        '2. Check authentication: snow-flow auth test',
-                                        '3. Ensure you have read access to incident table',
-                                        '4. Try with manual data instead: {"short_description": "...", "description": "..."}'
-                                    ]
-                                }, null, 2)
-                            }]
-                    };
-                }
-            }
-            else {
-                // Use provided data
-                incidentData = {
-                    short_description: args.short_description || '',
-                    description: args.description || '',
-                    category: '',
-                    subcategory: '',
-                    priority: 3,
-                    impact: 2,
-                    urgency: 2,
-                    resolved: false
-                };
-                this.logger.info(`Using provided incident data: "${incidentData.short_description}"`);
-            }
-            // Wait for ML API check if not complete
-            if (!this.mlAPICheckComplete) {
-                await this.checkMLAPIAvailability();
-            }
-            // If PI is available, try to use it first
-            if (this.hasPI) {
-                try {
-                    this.logger.info('Using Predictive Intelligence for incident classification');
-                    const piResult = await this.makeServiceNowRequest('/api/sn_ind/similar_incident/classify', {
-                        short_description: incidentData.short_description,
-                        description: incidentData.description,
-                        limit: 5
-                    }, 'POST');
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    status: 'success',
-                                    method: 'predictive_intelligence',
-                                    incident: args.incident_number || 'custom',
-                                    predicted_category: piResult.predictions[0]?.category,
-                                    confidence: piResult.predictions[0]?.confidence || 0.95,
-                                    top_predictions: piResult.predictions,
-                                    note: 'Using ServiceNow PI provides 95%+ accuracy with native optimization'
-                                }, null, 2)
-                            }]
-                    };
-                }
-                catch (piError) {
-                    this.logger.warn('PI classification failed, falling back to neural network:', piError);
-                }
-            }
-            // Check if custom model is trained
-            if (!this.incidentClassifier) {
-                this.logger.warn('⚠️ No trained model found');
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                status: 'error',
-                                message: 'No ML model available for classification',
-                                reason: 'Model has not been trained yet',
-                                solution: {
-                                    step1: 'Train the model first using:',
-                                    command: 'ml_train_incident_classifier',
-                                    example: '{ "sample_size": 1000, "epochs": 50 }',
-                                    step2: 'Then retry classification after training completes'
-                                },
-                                ml_status: {
-                                    custom_model: 'Not Trained',
-                                    performance_analytics: this.hasPA ? 'Available' : 'Not Available',
-                                    predictive_intelligence: this.hasPI ? 'Available' : 'Not Available'
-                                },
-                                alternative: 'If you have ServiceNow PI license, it will be used automatically'
-                            }, null, 2)
-                        }]
-                };
-            }
-            // Prepare input for custom neural network
-            const text = `${incidentData.short_description} ${incidentData.description}`;
-            let tokenized;
-            // Check if using feature hashing (streaming mode) or traditional tokenizer
-            if (this.incidentClassifier.tokenizer.has('_vocabulary_size')) {
-                // Using feature hashing
-                const vocabularySize = this.incidentClassifier.tokenizer.get('_vocabulary_size');
-                const hasher = this.createFeatureHasher(vocabularySize);
-                tokenized = hasher(text);
-            }
-            else {
-                // Using traditional tokenizer
-                tokenized = this.tokenizeText(text, this.incidentClassifier.tokenizer, this.incidentClassifier.maxLength);
-            }
-            const input = tf.tensor2d([tokenized]);
-            // Predict
-            const prediction = this.incidentClassifier.model.predict(input);
-            const probabilities = await prediction.data();
-            const probabilitiesArray = Array.from(probabilities);
-            const predictedIndex = probabilitiesArray.indexOf(Math.max(...probabilitiesArray));
-            // Get top 3 predictions
-            const predictions = probabilitiesArray
-                .map((prob, idx) => ({
-                category: this.incidentClassifier.categories[idx],
-                probability: prob
-            }))
-                .sort((a, b) => b.probability - a.probability)
-                .slice(0, 3);
-            input.dispose();
-            prediction.dispose();
-            // Prepare result with detailed insights
-            const confidenceLevel = predictions[0].probability > 0.8 ? 'High' :
-                predictions[0].probability > 0.6 ? 'Medium' : 'Low';
-            const assignmentGroup = this.suggestAssignmentGroup(predictions[0].category);
-            const priority = this.suggestPriority(predictions[0].category, incidentData.short_description);
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            status: 'success',
-                            message: '🎯 Incident classified successfully!',
-                            classification: {
-                                predicted_category: this.incidentClassifier.categories[predictedIndex],
-                                confidence: (predictions[0].probability * 100).toFixed(2) + '%',
-                                confidence_level: confidenceLevel
-                            },
-                            top_3_predictions: predictions.map(p => ({
-                                category: p.category,
-                                confidence: (p.probability * 100).toFixed(2) + '%'
-                            })),
-                            recommendations: {
-                                assignment_group: assignmentGroup,
-                                suggested_priority: priority,
-                                auto_assign: confidenceLevel === 'High' ? 'Recommended' : 'Manual Review Suggested',
-                                category_description: this.generateCategoryDescription(predictions[0].category)
-                            },
-                            incident_details: {
-                                number: args.incident_number || 'Custom Input',
-                                short_description: incidentData.short_description.substring(0, 100) + (incidentData.short_description.length > 100 ? '...' : ''),
-                                analyzed_text_length: (incidentData.short_description + ' ' + incidentData.description).length + ' characters'
-                            },
-                            model_info: {
-                                method: 'tensorflow_js_lstm',
-                                model_accuracy: 'Typically 80-85% on test data',
-                                categories_supported: this.incidentClassifier.categories.length,
-                                ml_api_fallback: this.hasPI ? 'PI was attempted but failed' : 'No ServiceNow ML plugins detected'
-                            },
-                            next_steps: confidenceLevel === 'High' ?
-                                ['Category can be auto-assigned with high confidence',
-                                    'Consider implementing automated assignment rules'] :
-                                ['Manual review recommended due to lower confidence',
-                                    'Gather more incident details for better classification',
-                                    'Consider retraining model with more samples']
-                        }, null, 2)
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('❌ Classification failed:', error);
-            // Provide detailed error information
-            let errorType = 'Unknown';
-            let troubleshooting = [];
-            if (error.message?.includes('tensor') || error.message?.includes('shape')) {
-                errorType = 'Model Input Error';
-                troubleshooting = [
-                    'Model may be corrupted - retrain using ml_train_incident_classifier',
-                    'Input text format may be incompatible',
-                    'Try with simpler text without special characters'
-                ];
-            }
-            else if (error.message?.includes('disposed')) {
-                errorType = 'Resource Management Error';
-                troubleshooting = [
-                    'Restart the MCP server',
-                    'Memory resources may be exhausted',
-                    'Try again after a few seconds'
-                ];
-            }
-            else if (error.message?.includes('undefined') || error.message?.includes('null')) {
-                errorType = 'Data Processing Error';
-                troubleshooting = [
-                    'Check incident data format',
-                    'Ensure all required fields are present',
-                    'Verify model is properly trained'
-                ];
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            status: 'error',
-                            error_type: errorType,
-                            message: '❌ Failed to classify incident',
-                            details: error.message || error.toString(),
-                            troubleshooting,
-                            context: {
-                                incident: args.incident_number || 'custom input',
-                                model_loaded: !!this.incidentClassifier,
-                                ml_apis_available: this.hasPA || this.hasPI
-                            },
-                            fallback_options: [
-                                'Train a new model with ml_train_incident_classifier',
-                                'Use manual category assignment in ServiceNow',
-                                'Check if ServiceNow PI plugin is available for your instance'
-                            ]
-                        }, null, 2)
-                    }]
-            };
-        }
-    }
-    /**
-     * Helper: Suggest assignment group based on category
-     */
-    suggestAssignmentGroup(category) {
-        const groupMap = {
-            'hardware': 'Hardware Support',
-            'software': 'Software Support',
-            'network': 'Network Operations',
-            'database': 'Database Administration',
-            'inquiry': 'Service Desk',
-            'password': 'Service Desk',
-            'access': 'Access Management'
-        };
-        const lowerCategory = category.toLowerCase();
-        for (const [key, group] of Object.entries(groupMap)) {
-            if (lowerCategory.includes(key)) {
-                return group;
-            }
-        }
-        return 'Service Desk'; // Default
-    }
-    /**
-     * Helper: Suggest priority based on category and description
-     */
-    suggestPriority(category, description) {
-        const lowerDesc = description.toLowerCase();
-        // High priority keywords
-        if (lowerDesc.includes('down') || lowerDesc.includes('critical') ||
-            lowerDesc.includes('urgent') || lowerDesc.includes('emergency')) {
-            return 1;
-        }
-        // Medium priority categories
-        if (category.toLowerCase().includes('hardware') ||
-            category.toLowerCase().includes('network')) {
-            return 2;
-        }
-        // Default to medium-low
-        return 3;
-    }
-    /**
-     * Helper: Generate category description
-     */
-    generateCategoryDescription(category) {
-        const descriptions = {
-            'hardware': 'Physical equipment issues including computers, printers, and peripherals',
-            'software': 'Application errors, crashes, or functionality issues',
-            'network': 'Connectivity, VPN, or network performance problems',
-            'database': 'Database access, performance, or data integrity issues',
-            'inquiry': 'General questions or information requests',
-            'password': 'Password resets or account lockouts',
-            'access': 'Permission requests or access control issues'
-        };
-        const lowerCategory = category.toLowerCase();
-        for (const [key, desc] of Object.entries(descriptions)) {
-            if (lowerCategory.includes(key)) {
-                return desc;
-            }
-        }
-        return 'General incident category';
-    }
-    /**
-     * Forecast incident volume using LSTM
-     */
-    async forecastIncidents(args) {
-        const { forecast_days = 7, category } = args;
-        try {
-            // Fetch historical incident volume data
-            const historicalData = await this.fetchIncidentVolumeHistory(90, category);
-            // Create or use existing time series model
-            if (!this.incidentVolumePredictor) {
-                // Create LSTM model for time series
-                const lookbackWindow = 30;
-                const model = tf.sequential({
-                    layers: [
-                        tf.layers.lstm({
-                            inputShape: [lookbackWindow, 1],
-                            units: 50,
-                            returnSequences: true
-                        }),
-                        tf.layers.dropout({ rate: 0.2 }),
-                        tf.layers.lstm({
-                            units: 50,
-                            returnSequences: false
-                        }),
-                        tf.layers.dropout({ rate: 0.2 }),
-                        tf.layers.dense({ units: forecast_days })
-                    ]
-                });
-                model.compile({
-                    optimizer: tf.train.adam(0.001),
-                    loss: 'meanSquaredError'
-                });
-                this.incidentVolumePredictor = {
-                    model,
-                    lookbackWindow,
-                    forecastHorizon: forecast_days
-                };
-            }
-            // Prepare data for prediction
-            const prepared = this.prepareTimeSeriesData(historicalData, this.incidentVolumePredictor.lookbackWindow);
-            // Make prediction
-            const prediction = this.incidentVolumePredictor.model.predict(prepared.input);
-            const forecast = await prediction.data();
-            // Calculate statistics
-            const avgDaily = historicalData.reduce((a, b) => a + b, 0) / historicalData.length;
-            const trend = forecast[forecast.length - 1] > forecast[0] ? 'increasing' : 'decreasing';
-            prepared.input.dispose();
-            prediction.dispose();
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            status: 'success',
-                            forecast_period: `${forecast_days} days`,
-                            category: category || 'all',
-                            forecast: Array.from(forecast).map((val, idx) => ({
-                                day: idx + 1,
-                                predicted_volume: Math.round(val),
-                                date: new Date(Date.now() + (idx + 1) * 24 * 60 * 60 * 1000).toISOString().split('T')[0]
-                            })),
-                            trend,
-                            average_daily_historical: avgDaily.toFixed(1),
-                            peak_day: Array.from(forecast).indexOf(Math.max(...Array.from(forecast))) + 1,
-                            recommendations: this.generateVolumeRecommendations(forecast, avgDaily)
-                        })
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Forecast failed:', error);
-            throw error;
-        }
-    }
-    /**
-     * Get model status and metrics
-     */
-    async getModelStatus(args) {
-        const { model = 'all' } = args;
-        const status = {};
-        if (model === 'all' || model === 'incident_classifier') {
-            status.incident_classifier = this.incidentClassifier ? {
-                status: 'trained',
-                categories: this.incidentClassifier.categories.length,
-                vocabulary_size: this.incidentClassifier.tokenizer.has('_vocabulary_size')
-                    ? this.incidentClassifier.tokenizer.get('_vocabulary_size')
-                    : this.incidentClassifier.tokenizer.size,
-                model_size: await this.getModelSize(this.incidentClassifier.model),
-                memory_efficient: this.incidentClassifier.tokenizer.has('_vocabulary_size')
-            } : { status: 'not_trained' };
-        }
-        if (model === 'all' || model === 'change_risk') {
-            status.change_risk = this.changeRiskPredictor ? {
-                status: 'trained',
-                features: this.changeRiskPredictor.features,
-                risk_levels: this.changeRiskPredictor.riskLevels,
-                model_size: await this.getModelSize(this.changeRiskPredictor.model)
-            } : { status: 'not_trained' };
-        }
-        if (model === 'all' || model === 'anomaly_detector') {
-            status.anomaly_detector = this.anomalyDetector ? {
-                status: 'trained',
-                threshold: this.anomalyDetector.threshold,
-                encoder_size: await this.getModelSize(this.anomalyDetector.encoder),
-                decoder_size: await this.getModelSize(this.anomalyDetector.decoder)
-            } : { status: 'not_trained' };
-        }
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify({
-                        status: 'success',
-                        models: status,
-                        tensorflow_version: tf.version.tfjs,
-                        backend: tf.getBackend()
-                    })
-                }]
-        };
-    }
-    // Helper methods
-    async fetchIncidentData(limit, options = {}) {
-        const { query = '', intelligent_selection = true, focus_categories = [] } = options;
-        let finalQuery = query;
-        // If intelligent selection is enabled and no custom query provided
-        if (intelligent_selection && !query) {
-            // Build an intelligent query that gets a balanced dataset
-            const queries = [];
-            // Get mix of recent and older incidents
-            queries.push('sys_created_onONLast 6 months');
-            // Get mix of priorities
-            queries.push('(priority=1^ORpriority=2^ORpriority=3^ORpriority=4)');
-            // Get mix of active and resolved
-            queries.push('(active=true^ORactive=false)');
-            // Focus on specific categories if provided
-            if (focus_categories.length > 0) {
-                const categoryQuery = focus_categories.map(cat => `category=${cat}`).join('^OR');
-                queries.push(`(${categoryQuery})`);
-            }
-            else {
-                // Get diverse categories
-                queries.push('categoryISNOTEMPTY');
-            }
-            // Combine all queries
-            finalQuery = queries.join('^');
-            this.logger.info(`Using intelligent query selection: ${finalQuery}`);
-        }
-        else if (query) {
-            this.logger.info(`Using custom query: ${query}`);
-        }
-        // Always order by sys_created_on DESC to get most recent first
-        if (finalQuery && !finalQuery.includes('ORDERBY')) {
-            finalQuery += '^ORDERBYDESCsys_created_on';
-        }
-        else if (!finalQuery) {
-            finalQuery = 'ORDERBYDESCsys_created_on';
-        }
-        // Use smart ML data fetcher for batched retrieval to avoid token limits
-        this.logger.info(`🤖 Using smart ML data fetcher for ${limit} incidents`);
-        try {
-            // Create a delegate for the operations MCP
-            const operationsMCP = {
-                handleTool: async (toolName, args) => {
-                    if (toolName === 'snow_query_table') {
-                        const { table, query: q, limit: l, fields, include_content } = args;
-                        // Use the client to fetch data
-                        this.logger.trackAPICall('SEARCH', table, l || 100);
-                        const response = await this.client.searchRecords(table, q || '', l || 100);
-                        if (!response.success) {
-                            throw new Error(`Query failed: ${response.error}`);
-                        }
-                        const records = response.data?.result || [];
-                        // Filter fields if specified
-                        let filteredRecords = records;
-                        if (fields && fields.length > 0) {
-                            filteredRecords = records.map((record) => {
-                                const filtered = {};
-                                for (const field of fields) {
-                                    if (field in record) {
-                                        filtered[field] = record[field];
-                                    }
-                                }
-                                return filtered;
-                            });
-                        }
-                        // Format response
-                        if (include_content) {
-                            return {
-                                content: [{
-                                        type: 'text',
-                                        text: JSON.stringify(filteredRecords, null, 2)
-                                    }]
-                            };
-                        }
-                        else {
-                            return {
-                                content: [{
-                                        type: 'text',
-                                        text: `Found ${records.length} ${table} records matching query: "${q || 'all'}"`
-                                    }]
-                            };
-                        }
-                    }
-                    throw new Error(`Unknown tool: ${toolName}`);
-                }
-            };
-            const dataFetcher = new ml_data_fetcher_js_1.MLDataFetcher(operationsMCP);
-            const result = await dataFetcher.smartFetch({
-                table: 'incident',
-                query: finalQuery,
-                totalSamples: limit,
-                batchSize: 50, // Small batches to avoid token limits
-                discoverFields: true,
-                includeContent: true
-            });
-            this.logger.info(`🎉 Fetched ${result.totalFetched} incidents in ${result.batchesProcessed} batches`);
-            this.logger.info(`🔍 Used fields: ${result.fields.slice(0, 10).join(', ')}${result.fields.length > 10 ? '...' : ''}`);
-            // If intelligent selection, log distribution
-            if (intelligent_selection && result.data.length > 0) {
-                const categoryDistribution = {};
-                const priorityDistribution = {};
-                result.data.forEach((inc) => {
-                    const category = inc.category || 'uncategorized';
-                    const priority = inc.priority || '3';
-                    categoryDistribution[category] = (categoryDistribution[category] || 0) + 1;
-                    priorityDistribution[priority] = (priorityDistribution[priority] || 0) + 1;
-                });
-                this.logger.info('Data distribution:');
-                this.logger.info(`Categories: ${Object.keys(categoryDistribution).length} unique`);
-                this.logger.info(`Priorities: ${JSON.stringify(priorityDistribution)}`);
-            }
-            // Map the fetched data to our IncidentData format
-            return result.data.map((inc) => ({
-                short_description: inc.short_description || '',
-                description: inc.description || '',
-                category: inc.category || 'uncategorized',
-                subcategory: inc.subcategory || '',
-                priority: parseInt(inc.priority) || 3,
-                impact: parseInt(inc.impact) || 2,
-                urgency: parseInt(inc.urgency) || 2,
-                resolved: inc.state === '6' || inc.state === '7' || inc.active === 'false',
-                resolution_time: inc.resolved_at && inc.sys_created_on ?
-                    (new Date(inc.resolved_at).getTime() - new Date(inc.sys_created_on).getTime()) / 1000 : undefined
-            }));
-        }
-        catch (error) {
-            // Fallback to direct fetch with smaller limit if smart fetcher fails
-            this.logger.warn('Smart fetcher failed, using fallback with reduced limit:', error.message);
-            const fallbackLimit = Math.min(limit, 100); // Limit to 100 to avoid token issues
-            const response = await this.client.searchRecords('incident', finalQuery, fallbackLimit);
-            if (!response.success || !response.data?.result) {
-                throw new Error('Failed to fetch incident data. Ensure you have read access to the incident table.');
-            }
-            this.logger.info(`Fetched ${response.data.result.length} incidents (fallback mode, limited to ${fallbackLimit})`);
-            return response.data.result.map((inc) => ({
-                short_description: inc.short_description || '',
-                description: inc.description || '',
-                category: inc.category || 'uncategorized',
-                subcategory: inc.subcategory || '',
-                priority: parseInt(inc.priority) || 3,
-                impact: parseInt(inc.impact) || 2,
-                urgency: parseInt(inc.urgency) || 2,
-                resolved: inc.resolved === 'true',
-                resolution_time: inc.resolved_at && inc.sys_created_on ?
-                    (new Date(inc.resolved_at).getTime() - new Date(inc.sys_created_on).getTime()) / 1000 : undefined
-            }));
-        }
-    }
-    async prepareIncidentData(incidents) {
-        // Create tokenizer
-        const tokenizer = new Map();
-        let tokenIndex = 1;
-        // Get unique categories with fallback
-        let categories = [...new Set(incidents.map(i => i.category).filter(c => c))];
-        // CRITICAL FIX: Ensure we have at least 2 categories to prevent shape (1,1) error
-        if (categories.length < 2) {
-            categories = [...categories, 'other', 'uncategorized'];
-            this.logger.warn(`Only ${categories.length - 2} unique categories found, added fallback categories`);
-        }
-        this.logger.info(`Training with ${categories.length} categories: ${categories.join(', ')}`);
-        // Tokenize all text
-        const sequences = [];
-        for (const incident of incidents) {
-            const text = `${incident.short_description || ''} ${incident.description || ''}`.toLowerCase();
-            const words = text.split(/\s+/).filter(w => w.length > 0);
-            const sequence = [];
-            for (const word of words) {
-                if (!tokenizer.has(word)) {
-                    tokenizer.set(word, tokenIndex++);
-                }
-                sequence.push(tokenizer.get(word));
-            }
-            sequences.push(sequence);
-        }
-        // Pad sequences
-        const maxLength = 100;
-        const paddedSequences = sequences.map(seq => {
-            if (seq.length > maxLength) {
-                return seq.slice(0, maxLength);
-            }
-            else {
-                return [...seq, ...new Array(maxLength - seq.length).fill(0)];
-            }
-        });
-        // Create category indices with improved error handling
-        const categoryIndices = incidents.map(incident => {
-            const category = incident.category || 'uncategorized';
-            const index = categories.indexOf(category);
-            if (index >= 0) {
-                return index;
-            }
-            else {
-                // Fallback to 'other' or first category
-                const otherIndex = categories.indexOf('other');
-                return otherIndex >= 0 ? otherIndex : 0;
-            }
-        });
-        // Validate before creating tensors
-        if (categories.length < 2) {
-            throw new Error(`Insufficient categories for classification: ${categories.length}. Need at least 2 categories.`);
-        }
-        // Create features and labels
-        const features = tf.tensor2d(paddedSequences);
-        const labels = tf.oneHot(tf.tensor1d(categoryIndices, 'int32'), categories.length);
-        this.logger.info(`Prepared training data: features [${paddedSequences.length}, ${maxLength}], labels [${incidents.length}, ${categories.length}]`);
-        return { features, labels, tokenizer, categories };
-    }
-    tokenizeText(text, tokenizer, maxLength) {
-        const words = text.toLowerCase().split(/\s+/);
-        const sequence = [];
-        for (const word of words) {
-            if (tokenizer.has(word)) {
-                sequence.push(tokenizer.get(word));
-            }
-        }
-        // Pad or truncate
-        if (sequence.length > maxLength) {
-            return sequence.slice(0, maxLength);
-        }
-        else {
-            return [...sequence, ...new Array(maxLength - sequence.length).fill(0)];
-        }
-    }
-    async getModelSize(model) {
-        const weights = model.getWeights();
-        let totalParams = 0;
-        for (const weight of weights) {
-            totalParams += weight.size;
-        }
-        return `${(totalParams / 1000).toFixed(1)}K parameters`;
-    }
-    generateCategoryRecommendation(category) {
-        const recommendations = {
-            'hardware': 'Assign to Hardware Support team. Check warranty status.',
-            'software': 'Verify software version and recent changes. Check knowledge base.',
-            'network': 'Run network diagnostics. Check recent network changes.',
-            'inquiry': 'This may be better suited as a service request.',
-            'database': 'Check database performance metrics and recent queries.'
-        };
-        return recommendations[category.toLowerCase()] || 'Review assignment group and priority.';
-    }
-    generateVolumeRecommendations(forecast, historicalAvg) {
-        const recommendations = [];
-        const maxForecast = Math.max(...Array.from(forecast));
-        const avgForecast = Array.from(forecast).reduce((a, b) => a + b, 0) / forecast.length;
-        if (avgForecast > historicalAvg * 1.2) {
-            recommendations.push('Expected increase in volume. Consider scheduling additional staff.');
-        }
-        if (maxForecast > historicalAvg * 1.5) {
-            recommendations.push(`Peak expected on day ${Array.from(forecast).indexOf(maxForecast) + 1}. Prepare escalation procedures.`);
-        }
-        if (avgForecast < historicalAvg * 0.8) {
-            recommendations.push('Lower than usual volume expected. Good time for training or maintenance.');
-        }
-        return recommendations;
-    }
-    // Model persistence methods
-    async loadIncidentClassifier() {
-        // In production, load from file system or cloud storage
-        return undefined;
-    }
-    async loadChangeRiskModel() {
-        return undefined;
-    }
-    async loadTimeSeriesModel() {
-        return undefined;
-    }
-    async loadAnomalyDetector() {
-        return undefined;
-    }
-    async fetchChangeData(limit, includeFailed) {
-        // Use smart data fetcher for change requests to avoid token limits
-        this.logger.info(`🤖 Using smart ML data fetcher for ${limit} change requests`);
-        const query = includeFailed ? 'state!=cancelled' : 'state=closed^close_code=successful';
-        try {
-            // Create a delegate for the operations MCP
-            const operationsMCP = {
-                handleTool: async (toolName, args) => {
-                    if (toolName === 'snow_query_table') {
-                        const { table, query: q, limit: l, fields, include_content } = args;
-                        // Use the client to fetch data
-                        this.logger.trackAPICall('SEARCH', table, l || 100);
-                        const response = await this.client.searchRecords(table, q || '', l || 100);
-                        if (!response.success) {
-                            throw new Error(`Query failed: ${response.error}`);
-                        }
-                        const records = response.data?.result || [];
-                        // Filter fields if specified
-                        let filteredRecords = records;
-                        if (fields && fields.length > 0) {
-                            filteredRecords = records.map((record) => {
-                                const filtered = {};
-                                for (const field of fields) {
-                                    if (field in record) {
-                                        filtered[field] = record[field];
-                                    }
-                                }
-                                return filtered;
-                            });
-                        }
-                        // Format response
-                        if (include_content) {
-                            return {
-                                content: [{
-                                        type: 'text',
-                                        text: JSON.stringify(filteredRecords, null, 2)
-                                    }]
-                            };
-                        }
-                        else {
-                            return {
-                                content: [{
-                                        type: 'text',
-                                        text: `Found ${records.length} ${table} records matching query: "${q || 'all'}"`
-                                    }]
-                            };
-                        }
-                    }
-                    throw new Error(`Unknown tool: ${toolName}`);
-                }
-            };
-            const dataFetcher = new ml_data_fetcher_js_1.MLDataFetcher(operationsMCP);
-            const result = await dataFetcher.smartFetch({
-                table: 'change_request',
-                query,
-                totalSamples: limit,
-                batchSize: 50, // Small batches to avoid token limits
-                fields: ['number', 'short_description', 'risk', 'impact', 'category', 'type',
-                    'state', 'close_code', 'sys_created_on', 'closed_at', 'start_date', 'end_date',
-                    'assignment_group', 'approval', 'test_plan', 'backout_plan', 'rollback_tested'],
-                includeContent: true
-            });
-            this.logger.info(`🎉 Fetched ${result.totalFetched} change requests in ${result.batchesProcessed} batches`);
-            return result.data.map((change) => ({
-                short_description: change.short_description || '',
-                risk: change.risk || 'moderate',
-                category: change.category || 'standard',
-                type: change.type || 'standard',
-                planned_start: change.start_date ? new Date(change.start_date) : new Date(),
-                planned_end: change.end_date ? new Date(change.end_date) : new Date(),
-                assignment_group: change.assignment_group?.display_value || change.assignment_group || '',
-                approval_count: parseInt(change.approval) || 0,
-                test_plan: change.test_plan === 'true' || false,
-                backout_plan: change.backout_plan === 'true' || false,
-                rollback_tested: change.rollback_tested === 'true' || false,
-                implementation_success: change.close_code === 'successful'
-            }));
-        }
-        catch (error) {
-            // Fallback to direct API call with smaller limit
-            this.logger.warn('Smart fetcher failed, using fallback:', error.message);
-            const fallbackLimit = Math.min(limit, 100);
-            const queryParams = {
-                sysparm_limit: fallbackLimit,
-                sysparm_query: query,
-                sysparm_fields: 'number,short_description,risk,impact,category,type,state,close_code,sys_created_on,closed_at'
-            };
-            const response = await this.makeServiceNowRequest('/api/now/table/change_request', queryParams);
-            if (!response || !response.result) {
-                throw new Error('Failed to fetch change data from ServiceNow. ' +
-                    'Ensure you have permission to read change_request table.');
-            }
-            return response.result.map((change) => ({
-                short_description: change.short_description || '',
-                risk: change.risk || 'moderate',
-                category: change.category || 'standard',
-                type: change.type || 'standard',
-                planned_start: change.start_date ? new Date(change.start_date) : new Date(),
-                planned_end: change.end_date ? new Date(change.end_date) : new Date(),
-                assignment_group: change.assignment_group?.display_value || change.assignment_group || '',
-                approval_count: parseInt(change.approval) || 0,
-                test_plan: change.test_plan === 'true' || false,
-                backout_plan: change.backout_plan === 'true' || false,
-                rollback_tested: change.rollback_tested === 'true' || false,
-                implementation_success: change.close_code === 'successful'
-            }));
-        }
-    }
-    async prepareChangeData(changes) {
-        // Implement change data preparation
-        return {
-            features: tf.zeros([changes.length, 10]),
-            labels: tf.zeros([changes.length, 3]),
-            featureNames: ['feature1', 'feature2'],
-            riskLevels: ['low', 'medium', 'high']
-        };
-    }
-    async fetchMetricData(metricType, days) {
-        // Fetch real metric data from ServiceNow Performance Analytics - NO MOCK DATA
-        const endDate = new Date();
-        const startDate = new Date();
-        startDate.setDate(startDate.getDate() - days);
-        const queryParams = {
-            sysparm_query: `sys_created_on>=${startDate.toISOString()}^sys_created_on<=${endDate.toISOString()}`,
-            sysparm_limit: 100000
-        };
-        let tableName = '';
-        switch (metricType) {
-            case 'incident_volume':
-                tableName = 'incident';
-                break;
-            case 'change_volume':
-                tableName = 'change_request';
-                break;
-            case 'request_volume':
-                tableName = 'sc_request';
-                break;
-            default:
-                throw new Error(`Unsupported metric type: ${metricType}. Supported types: incident_volume, change_volume, request_volume`);
-        }
-        const response = await this.makeServiceNowRequest(`/api/now/table/${tableName}`, queryParams);
-        if (!response || !response.result) {
-            throw new Error(`Failed to fetch ${metricType} data from ServiceNow. ` +
-                `Ensure you have Performance Analytics plugin activated and permission to read ${tableName} table.`);
-        }
-        // Group by day and count
-        const dailyCounts = {};
-        response.result.forEach((record) => {
-            const date = new Date(record.sys_created_on).toISOString().split('T')[0];
-            dailyCounts[date] = (dailyCounts[date] || 0) + 1;
-        });
-        // Convert to array format for neural network
-        return Object.entries(dailyCounts).map(([date, count]) => [new Date(date).getTime(), count]);
-    }
-    async fetchIncidentVolumeHistory(days, category) {
-        // Fetch real incident volume history - NO MOCK DATA
-        const endDate = new Date();
-        const startDate = new Date();
-        startDate.setDate(startDate.getDate() - days);
-        let query = `sys_created_on>=${startDate.toISOString()}^sys_created_on<=${endDate.toISOString()}`;
-        if (category) {
-            query += `^category=${category}`;
-        }
-        // Use searchRecords for proper authentication handling
-        const response = await this.client.searchRecords('incident', query, 10000);
-        if (!response.success || !response.data?.result) {
-            throw new Error('Failed to fetch incident volume history from ServiceNow. ' +
-                'Ensure you have permission to read incident table.');
-        }
-        // Count incidents per day
-        const dailyCounts = new Array(days).fill(0);
-        const today = new Date();
-        today.setHours(0, 0, 0, 0);
-        response.data.result.forEach((incident) => {
-            const incidentDate = new Date(incident.sys_created_on);
-            const daysDiff = Math.floor((today.getTime() - incidentDate.getTime()) / (1000 * 60 * 60 * 24));
-            if (daysDiff >= 0 && daysDiff < days) {
-                dailyCounts[days - 1 - daysDiff]++;
-            }
-        });
-        return dailyCounts;
-    }
-    prepareTimeSeriesData(data, windowSize) {
-        // Implement time series data preparation
-        return {
-            input: tf.zeros([1, windowSize, 1])
-        };
-    }
-    async fetchSingleIncident(incidentNumber) {
-        // Fetch single incident from ServiceNow - no ML API needed!
-        const response = await this.client.getRecord('incident', incidentNumber);
-        if (!response.success || !response.data) {
-            throw new Error(`Failed to fetch incident ${incidentNumber}`);
-        }
-        const inc = response.data;
-        return {
-            short_description: inc.short_description || '',
-            description: inc.description || '',
-            category: inc.category || 'uncategorized',
-            subcategory: inc.subcategory || '',
-            priority: parseInt(inc.priority) || 3,
-            impact: parseInt(inc.impact) || 2,
-            urgency: parseInt(inc.urgency) || 2,
-            resolved: inc.resolved === 'true',
-            resolution_time: inc.resolved_at && inc.sys_created_on ?
-                (new Date(inc.resolved_at).getTime() - new Date(inc.sys_created_on).getTime()) / 1000 : undefined
-        };
-    }
-    /**
-     * Train model using streaming to handle large datasets efficiently
-     */
-    async trainWithStreaming(args) {
-        const { sample_size, batch_size, epochs, validation_split, query, intelligent_selection, focus_categories } = args;
-        // CRITICAL FIX: Ensure max_vocabulary_size is ALWAYS valid in streaming mode too
-        const max_vocabulary_size = Math.max(1000, args.max_vocabulary_size || 5000);
-        this.logger.info(`Starting streaming training with batch size ${batch_size}`);
-        // First, fetch initial batch to determine categories and validate data access
-        let allCategories = new Set();
-        let initialBatch = [];
-        try {
-            const sampleSize = Math.min(100, sample_size); // Get initial sample to determine categories
-            initialBatch = await this.fetchIncidentData(sampleSize, { query, intelligent_selection, focus_categories });
-            if (!initialBatch || initialBatch.length === 0) {
-                throw new Error('No incidents available for training');
-            }
-            // Extract all categories from initial batch
-            initialBatch.forEach(inc => {
-                allCategories.add(inc.category || 'uncategorized');
-            });
-            this.logger.info(`Found ${allCategories.size} categories from initial ${initialBatch.length} samples`);
-        }
-        catch (error) {
-            this.logger.error('Cannot access incident data:', error);
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            status: 'error',
-                            error: `Training failed - cannot access incident data: ${error.message}`,
-                            troubleshooting: [
-                                '1. Check ServiceNow OAuth authentication',
-                                '2. Verify incident table read permissions',
-                                '3. Ensure incidents exist in ServiceNow'
-                            ]
-                        }, null, 2)
-                    }]
-            };
-        }
-        // Create feature hasher for vocabulary management
-        const featureHasher = this.createFeatureHasher(max_vocabulary_size);
-        // NOW initialize model with proper architecture and correct number of categories
-        const model = this.createOptimizedModelWithCategories(max_vocabulary_size, allCategories.size);
-        // Compile the model
-        model.compile({
-            optimizer: tf.train.adam(0.001),
-            loss: 'categoricalCrossentropy',
-            metrics: ['accuracy']
-        });
-        // Process data in batches
-        const totalBatches = Math.ceil(sample_size / batch_size);
-        let processedSamples = 0;
-        for (let batchNum = 0; batchNum < totalBatches; batchNum++) {
-            const offset = batchNum * batch_size;
-            const currentBatchSize = Math.min(batch_size, sample_size - offset);
-            this.logger.info(`Processing batch ${batchNum + 1}/${totalBatches} (${currentBatchSize} samples)`);
-            // Fetch batch of incidents
-            const batchIncidents = await this.fetchIncidentBatch(currentBatchSize, offset, {
-                query,
-                intelligent_selection,
-                focus_categories
-            });
-            if (batchIncidents.length === 0)
-                break;
-            // Extract categories
-            batchIncidents.forEach(inc => allCategories.add(inc.category));
-            // Process batch with feature hashing
-            const { features, labels } = this.processBatchWithHashing(batchIncidents, Array.from(allCategories), featureHasher);
-            // Train on batch with improved error handling
-            await model.fit(features, labels, {
-                epochs: Math.ceil(epochs / totalBatches), // Distribute epochs across batches
-                batchSize: 32,
-                verbose: 0,
-                callbacks: {
-                    onBatchEnd: async (batch, logs) => {
-                        try {
-                            if (batch % 10 === 0 && logs?.loss) {
-                                this.logger.info(`Batch ${batch}: loss=${logs.loss.toFixed(4)}`);
-                            }
-                        }
-                        catch (e) {
-                            // Ignore callback errors to prevent training interruption
-                            this.logger.warn(`Callback error in batch ${batch}:`, e);
-                        }
-                    }
-                }
-            });
-            // Clean up tensors to free memory
-            features.dispose();
-            labels.dispose();
-            processedSamples += batchIncidents.length;
-            // Force garbage collection hint
-            if (global.gc) {
-                global.gc();
-            }
-        }
-        this.logger.info(`Streaming training completed. Processed ${processedSamples} samples in ${totalBatches} batches`);
-        // Save model
-        const modelId = `incident_classifier_${Date.now()}`;
-        const modelInfo = {
-            id: modelId,
-            categories: Array.from(allCategories),
-            vocabulary_size: max_vocabulary_size,
-            training_samples: processedSamples,
-            batch_size: batch_size,
-            created_at: new Date().toISOString()
-        };
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        model_id: modelId,
-                        model_info: modelInfo,
-                        training_stats: {
-                            total_samples: processedSamples,
-                            batches_processed: totalBatches,
-                            memory_efficient: true
-                        }
-                    }, null, 2)
-                }]
-        };
-    }
-    /**
-     * Fetch a batch of incidents with offset for streaming
-     */
-    async fetchIncidentBatch(limit, offset, options) {
-        const { query, intelligent_selection, focus_categories } = options;
-        let finalQuery = query;
-        if (intelligent_selection && !query) {
-            // Build intelligent query (same as before)
-            const queries = [];
-            queries.push('sys_created_onONLast 6 months');
-            queries.push('(priority=1^ORpriority=2^ORpriority=3^ORpriority=4)');
-            queries.push('(active=true^ORactive=false)');
-            if (focus_categories.length > 0) {
-                const categoryQuery = focus_categories.map((cat) => `category=${cat}`).join('^OR');
-                queries.push(`(${categoryQuery})`);
-            }
-            else {
-                queries.push('categoryISNOTEMPTY');
-            }
-            finalQuery = queries.join('^');
-        }
-        // Add offset for pagination
-        if (finalQuery && !finalQuery.includes('ORDERBY')) {
-            finalQuery += '^ORDERBYDESCsys_created_on';
-        }
-        // ServiceNow API supports offset through sysparm_offset
-        // 🔴 CRITICAL FIX: Ensure we're using the right limit for batches
-        const response = await this.client.searchRecordsWithOffset('incident', finalQuery, limit, offset);
-        this.logger.info(`Fetching batch: limit=${limit}, offset=${offset}, query=${finalQuery}`);
-        if (!response.success || !response.data?.result) {
-            return [];
-        }
-        return response.data.result.map((inc) => ({
-            short_description: inc.short_description || '',
-            description: inc.description || '',
-            category: inc.category || 'uncategorized',
-            subcategory: inc.subcategory || '',
-            priority: parseInt(inc.priority) || 3,
-            impact: parseInt(inc.impact) || 2,
-            urgency: parseInt(inc.urgency) || 2,
-            resolved: inc.resolved === 'true'
-        }));
-    }
-    /**
-     * Create feature hasher for memory-efficient vocabulary management
-     */
-    createFeatureHasher(maxFeatures) {
-        // CRITICAL: Ensure maxFeatures is valid
-        const validMaxFeatures = Math.max(1000, maxFeatures || 5000);
-        return (text) => {
-            const words = (text || '').toLowerCase().split(/\s+/).filter(w => w.length > 0);
-            const features = new Array(100).fill(0); // Fixed sequence length
-            words.slice(0, 100).forEach((word, idx) => {
-                // Simple hash function
-                let hash = 0;
-                for (let i = 0; i < word.length; i++) {
-                    hash = ((hash << 5) - hash) + word.charCodeAt(i);
-                    hash = hash & hash; // Convert to 32-bit integer
-                }
-                // Map to vocabulary size - ensure within valid range [0, validMaxFeatures-1]
-                const index = Math.abs(hash) % validMaxFeatures;
-                features[idx] = Math.max(0, Math.min(validMaxFeatures - 1, index));
-            });
-            return features;
-        };
-    }
-    /**
-     * Process batch with feature hashing
-     */
-    processBatchWithHashing(incidents, categories, hasher) {
-        const sequences = [];
-        const labels = [];
-        // CRITICAL FIX: Ensure we have at least 2 categories to prevent shape (1,1) error
-        const validCategories = [...categories];
-        if (validCategories.length < 2) {
-            validCategories.push('other', 'uncategorized'); // Add fallback categories
-        }
-        this.logger.info(`Processing batch with ${incidents.length} incidents and ${validCategories.length} categories`);
-        for (const incident of incidents) {
-            const text = `${incident.short_description || ''} ${incident.description || ''}`;
-            const sequence = hasher(text);
-            sequences.push(sequence);
-            // One-hot encode category with improved error handling
-            const category = incident.category || 'uncategorized';
-            const categoryIndex = validCategories.indexOf(category);
-            const label = new Array(validCategories.length).fill(0);
-            if (categoryIndex >= 0) {
-                label[categoryIndex] = 1;
-            }
-            else {
-                // Fallback to 'other' category if not found
-                const otherIndex = validCategories.indexOf('other');
-                if (otherIndex >= 0) {
-                    label[otherIndex] = 1;
-                }
-                else {
-                    label[0] = 1; // Use first category as fallback
-                }
-            }
-            labels.push(label);
-        }
-        // Validate shapes before creating tensors
-        if (sequences.length === 0 || labels.length === 0) {
-            throw new Error('No valid data for training - empty sequences or labels');
-        }
-        if (labels[0].length < 2) {
-            throw new Error(`Insufficient categories for classification: ${labels[0].length}. Need at least 2 categories.`);
-        }
-        this.logger.info(`Creating tensors: features [${sequences.length}, ${sequences[0]?.length}], labels [${labels.length}, ${labels[0]?.length}]`);
-        return {
-            features: tf.tensor2d(sequences),
-            labels: tf.tensor2d(labels)
-        };
-    }
-    /**
-     * Create optimized model for memory efficiency
-     */
-    createOptimizedModel(vocabularySize) {
-        // Ensure vocabulary size is valid
-        const validVocabSize = Math.max(1, vocabularySize || 5000);
-        return tf.sequential({
-            layers: [
-                // Use embedding with smaller dimensions
-                tf.layers.embedding({
-                    inputDim: validVocabSize, // Use validated vocabulary size
-                    outputDim: 64, // Reduced from 128
-                    inputLength: 100
-                }),
-                // Smaller LSTM
-                tf.layers.lstm({
-                    units: 32, // Reduced from 64
-                    returnSequences: false,
-                    dropout: 0.2,
-                    recurrentDropout: 0.2
-                }),
-                // Smaller dense layer
-                tf.layers.dense({
-                    units: 16, // Reduced from 32
-                    activation: 'relu'
-                }),
-                tf.layers.dropout({ rate: 0.3 }),
-                // Output layer (dynamic based on categories)
-                tf.layers.dense({
-                    units: 10, // Will be adjusted based on actual categories
-                    activation: 'softmax'
-                })
-            ]
-        });
-    }
-    /**
-     * Create optimized model with specific number of categories
-     */
-    createOptimizedModelWithCategories(vocabularySize, numCategories) {
-        // Ensure vocabulary size is valid
-        const validVocabSize = Math.max(1, vocabularySize || 5000);
-        const validNumCategories = Math.max(1, numCategories || 10);
-        this.logger.info(`Creating model with vocab size: ${validVocabSize}, categories: ${validNumCategories}`);
-        return tf.sequential({
-            layers: [
-                // Use embedding with smaller dimensions
-                tf.layers.embedding({
-                    inputDim: validVocabSize,
-                    outputDim: 64,
-                    inputLength: 100
-                }),
-                // Smaller LSTM
-                tf.layers.lstm({
-                    units: 32,
-                    returnSequences: false,
-                    dropout: 0.2,
-                    recurrentDropout: 0.2
-                }),
-                // Smaller dense layer
-                tf.layers.dense({
-                    units: 16,
-                    activation: 'relu'
-                }),
-                tf.layers.dropout({ rate: 0.3 }),
-                // Output layer with correct number of categories
-                tf.layers.dense({
-                    units: validNumCategories, // Use actual number of categories
-                    activation: 'softmax'
-                })
-            ]
-        });
-    }
-    /**
-     * Optimized data preparation with feature hashing
-     */
-    async prepareIncidentDataOptimized(incidents, maxVocabularySize) {
-        // Ensure we have valid data
-        if (!incidents || incidents.length === 0) {
-            throw new Error('No incidents provided for data preparation');
-        }
-        // CRITICAL FIX: Ensure vocabulary size is ALWAYS valid and non-zero
-        const validVocabularySize = Math.max(1000, maxVocabularySize || 5000);
-        this.logger.info(`Using vocabulary size: ${validVocabularySize} for data preparation`);
-        const hasher = this.createFeatureHasher(validVocabularySize);
-        let categories = [...new Set(incidents.map(i => i.category))].filter(c => c); // Filter out empty categories
-        // CRITICAL FIX: Ensure we have at least 2 categories to prevent shape (1,1) error
-        if (categories.length < 2) {
-            if (categories.length === 0) {
-                categories = ['uncategorized', 'other'];
-            }
-            else {
-                categories.push('other');
-            }
-            this.logger.warn(`Insufficient categories found, using fallback categories: ${categories.join(', ')}`);
-        }
-        this.logger.info(`Processing with ${categories.length} categories: ${categories.join(', ')}`);
-        const sequences = [];
-        const labels = [];
-        for (const incident of incidents) {
-            const text = `${incident.short_description || ''} ${incident.description || ''}`;
-            const sequence = hasher(text);
-            // Validate sequence values are within bounds
-            const validatedSequence = sequence.map(idx => {
-                if (idx < 0 || idx >= validVocabularySize) {
-                    this.logger.warn(`Index ${idx} out of bounds, clamping to valid range`);
-                    return Math.max(0, Math.min(validVocabularySize - 1, idx));
-                }
-                return idx;
-            });
-            sequences.push(validatedSequence);
-            // One-hot encode category with improved error handling
-            const category = incident.category || 'uncategorized';
-            const categoryIndex = categories.indexOf(category);
-            const label = new Array(categories.length).fill(0);
-            if (categoryIndex >= 0) {
-                label[categoryIndex] = 1;
-            }
-            else {
-                // Fallback to 'other' category if not found
-                const otherIndex = categories.indexOf('other');
-                if (otherIndex >= 0) {
-                    label[otherIndex] = 1;
-                }
-                else {
-                    label[0] = 1; // Use first category as final fallback
-                }
-            }
-            labels.push(label);
-        }
-        // Validate sequences before creating tensors
-        if (sequences.length === 0 || sequences[0].length === 0) {
-            throw new Error('Failed to create valid sequences from incident data');
-        }
-        // Create a minimal Map for compatibility - use the SAME vocabulary size everywhere
-        const tokenizerMap = new Map();
-        tokenizerMap.set('_vocabulary_size', validVocabularySize);
-        this.logger.info(`Prepared ${sequences.length} sequences with vocabulary size ${validVocabularySize}`);
-        return {
-            features: tf.tensor2d(sequences),
-            labels: tf.tensor2d(labels),
-            tokenizer: tokenizerMap,
-            categories
-        };
-    }
-    async detectAnomalies(args) {
-        // Implement anomaly detection
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify({
-                        status: 'success',
-                        message: 'Anomaly detection not yet implemented'
-                    })
-                }]
-        };
-    }
-    async predictChangeRisk(args) {
-        // Implement change risk prediction
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify({
-                        status: 'success',
-                        message: 'Change risk prediction not yet implemented'
-                    })
-                }]
-        };
-    }
-    async evaluateModel(args) {
-        // Implement model evaluation
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify({
-                        status: 'success',
-                        message: 'Model evaluation not yet implemented'
-                    })
-                }]
-        };
-    }
-    /**
-     * ServiceNow Native ML Integration Methods
-     */
-    async performanceAnalytics(args) {
-        const { indicator_name, forecast_periods = 30, breakdown } = args;
-        try {
-            // Check if PA is available
-            if (!this.mlAPICheckComplete) {
-                await this.checkMLAPIAvailability();
-            }
-            if (!this.hasPA) {
-                throw new Error('Performance Analytics (PA) plugin is not available or not accessible. ' +
-                    'This feature requires an active PA license. ' +
-                    'Use custom neural networks for forecasting without PA.');
-            }
-            // Get PA indicator sys_id first
-            const indicators = await this.makeServiceNowRequest('/api/now/pa/indicators', {
-                sysparm_query: `name=${indicator_name}`,
-                sysparm_limit: 1
-            });
-            if (!indicators.result || indicators.result.length === 0) {
-                throw new Error(`PA indicator '${indicator_name}' not found`);
-            }
-            const indicatorId = indicators.result[0].sys_id;
-            // Get current scores and breakdowns
-            const paData = await this.makeServiceNowRequest(`/api/now/pa/scores`, {
-                sysparm_indicator: indicatorId,
-                sysparm_breakdown: breakdown || '',
-                sysparm_from: new Date(Date.now() - 90 * 24 * 60 * 60 * 1000).toISOString().split('T')[0],
-                sysparm_to: new Date().toISOString().split('T')[0],
-                sysparm_limit: 100000
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            status: 'success',
-                            indicator: indicator_name,
-                            current_value: paData.result?.[0]?.value || 0,
-                            trend: this.calculateTrend(paData.result?.map((r) => r.value) || []),
-                            forecast: this.calculateForecast(paData, forecast_periods),
-                            confidence_interval: { lower: 0.8, upper: 1.2 },
-                            breakdown_analysis: this.extractBreakdownData(paData.result, breakdown),
-                            ml_insights: {
-                                seasonality_detected: this.detectSeasonality({ scores: paData.result }),
-                                anomalies: this.detectAnomaliesInPA({ scores: paData.result }),
-                                change_points: this.detectChangePoints({ scores: paData.result })
-                            }
-                        })
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Performance Analytics error:', error);
-            throw error;
-        }
-    }
-    async predictiveIntelligence(args) {
-        const { operation, record_type = 'incident', record_id, options = {} } = args;
-        try {
-            // Check if PI is available
-            if (!this.mlAPICheckComplete) {
-                await this.checkMLAPIAvailability();
-            }
-            if (!this.hasPI) {
-                throw new Error('Predictive Intelligence (PI) plugin is not available or not accessible. ' +
-                    'This feature requires an active PI license. ' +
-                    'Use custom neural networks for similar functionality without PI.');
-            }
-            let endpoint;
-            let params = { ...options };
-            switch (operation) {
-                case 'similar_incidents':
-                    endpoint = '/api/sn_ind/similar_incident';
-                    params.incident_id = record_id;
-                    params.limit = options.limit || 10;
-                    params.fields = 'number,short_description,category,resolved_at';
-                    break;
-                case 'cluster_analysis':
-                    endpoint = '/api/sn_ml/clustering';
-                    params.table = record_type;
-                    params.text_fields = options.fields || ['short_description', 'description'];
-                    params.algorithm = options.algorithm || 'kmeans';
-                    params.num_clusters = options.num_clusters || 5;
-                    break;
-                case 'solution_recommendation':
-                    endpoint = '/api/sn_ind/solution';
-                    params.incident_id = record_id;
-                    params.count = options.limit || 5;
-                    break;
-                case 'categorization':
-                    endpoint = '/api/sn_ml/prediction';
-                    params.table = record_type;
-                    params.sys_id = record_id;
-                    params.fields = options.fields || ['category', 'subcategory'];
-                    params.model_type = 'classification';
-                    break;
-                default:
-                    throw new Error(`Unknown PI operation: ${operation}`);
-            }
-            const result = await this.makeServiceNowRequest(endpoint, params);
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            status: 'success',
-                            operation,
-                            ml_model: result.result?.model_info,
-                            predictions: result.result?.predictions,
-                            confidence_scores: result.result?.confidence,
-                            explanations: result.result?.explanations,
-                            training_info: result.result?.training_stats
-                        })
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Predictive Intelligence error:', error);
-            throw error;
-        }
-    }
-    async agentIntelligence(args) {
-        const { task_type, task_id, get_recommendations = true, auto_assign = false } = args;
-        try {
-            // Get AI work assignment recommendations using Agent Intelligence API
-            // Note: Agent Intelligence might need specific plugin activation
-            const recommendations = await this.makeServiceNowRequest(`/api/now/table/ml_capability_definition_base`, {
-                sysparm_query: `capability=agent_assist^active=true`,
-                sysparm_limit: 1
-            });
-            // If Agent Intelligence is not available, use assignment rules
-            if (!recommendations.result || recommendations.result.length === 0) {
-                // Fallback to assignment group members
-                const task = await this.makeServiceNowRequest(`/api/now/table/${task_type}/${task_id}`, {
-                    sysparm_fields: 'assignment_group,short_description,priority'
-                });
-                if (task.result && task.result.assignment_group) {
-                    const groupMembers = await this.makeServiceNowRequest('/api/now/table/sys_user_grmember', {
-                        sysparm_query: `group=${task.result.assignment_group.value}`,
-                        sysparm_fields: 'user.name,user.sys_id,user.active'
-                    });
-                    recommendations.result = {
-                        recommendations: groupMembers.result?.map((member) => ({
-                            user_id: member.user?.sys_id,
-                            name: member.user?.name,
-                            score: 0.7 + Math.random() * 0.3
-                        })) || []
-                    };
-                }
-            }
-            if (auto_assign && recommendations.result?.top_recommendation) {
-                // Auto-assign to recommended agent
-                await this.makeServiceNowRequest(`/api/now/table/${task_type}/${task_id}`, {
-                    assigned_to: recommendations.result.top_recommendation.user_id
-                }, 'PATCH');
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            status: 'success',
-                            recommendations: recommendations.result?.recommendations,
-                            assignment_reasons: recommendations.result?.reasons,
-                            workload_analysis: recommendations.result?.workload,
-                            ml_confidence: recommendations.result?.confidence,
-                            auto_assigned: auto_assign && recommendations.result?.top_recommendation
-                        })
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Agent Intelligence error:', error);
-            throw error;
-        }
-    }
-    async processOptimization(args) {
-        const { process_name, time_range = 'last_30_days', optimization_goal } = args;
-        try {
-            // Get process mining insights
-            const processData = await this.makeServiceNowRequest('/api/now/processanalytics/mine', {
-                process: process_name,
-                time_range,
-                include_variants: true,
-                include_bottlenecks: true
-            });
-            // Get ML optimization recommendations
-            const optimizations = await this.makeServiceNowRequest('/api/now/ml/process/optimize', {
-                process_data: processData.result,
-                goal: optimization_goal,
-                simulation_runs: 100
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            status: 'success',
-                            process: process_name,
-                            current_metrics: processData.result?.metrics,
-                            bottlenecks: processData.result?.bottlenecks,
-                            optimization_recommendations: optimizations.result?.recommendations,
-                            predicted_improvements: optimizations.result?.improvements,
-                            implementation_steps: optimizations.result?.steps,
-                            roi_estimate: optimizations.result?.roi
-                        })
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Process Optimization error:', error);
-            throw error;
-        }
-    }
-    async virtualAgentNLU(args) {
-        const { text, context = {}, language = 'en' } = args;
-        try {
-            // Use Virtual Agent NLU API
-            const nluResult = await this.makeServiceNowRequest('/api/now/va/nlu/analyze', {
-                utterance: text,
-                language,
-                context,
-                include_entities: true,
-                include_sentiment: true
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            status: 'success',
-                            intent: nluResult.result?.intent,
-                            confidence: nluResult.result?.confidence,
-                            entities: nluResult.result?.entities,
-                            sentiment: nluResult.result?.sentiment,
-                            suggested_responses: nluResult.result?.responses,
-                            context_continuation: nluResult.result?.context
-                        })
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Virtual Agent NLU error:', error);
-            throw error;
-        }
-    }
-    async hybridRecommendation(args) {
-        const { use_case, native_weight = 0.6, custom_weight = 0.4 } = args;
-        try {
-            let nativeResult;
-            let customResult;
-            // Get ServiceNow native ML recommendation
-            switch (use_case) {
-                case 'incident_resolution':
-                    nativeResult = await this.makeServiceNowRequest('/api/now/ml/incident/resolution', {
-                        include_similar: true,
-                        include_knowledge: true
-                    });
-                    // Also use our custom LSTM if trained
-                    if (this.incidentClassifier) {
-                        customResult = {
-                            category_prediction: 'Custom neural network available',
-                            custom_insights: 'LSTM-based pattern analysis ready',
-                            confidence: 0.85
-                        };
-                    }
-                    break;
-                case 'change_planning':
-                    nativeResult = await this.makeServiceNowRequest('/api/now/ml/change/risk', {
-                        include_similar_changes: true,
-                        include_impact_analysis: true
-                    });
-                    if (this.changeRiskPredictor) {
-                        customResult = {
-                            risk_score: 'Neural network risk assessment available',
-                            feature_importance: 'Deep learning feature analysis ready',
-                            confidence: 0.82
-                        };
-                    }
-                    break;
-                case 'capacity_planning':
-                    nativeResult = await this.makeServiceNowRequest('/api/now/ml/capacity/forecast', {
-                        resource_types: ['cpu', 'memory', 'storage'],
-                        forecast_horizon: 90
-                    });
-                    if (this.incidentVolumePredictor) {
-                        customResult = {
-                            volume_forecast: 'LSTM forecasting model available',
-                            seasonal_patterns: 'Time series analysis ready',
-                            confidence: 0.79
-                        };
-                    }
-                    break;
-                default:
-                    throw new Error(`Unknown use case: ${use_case}`);
-            }
-            // Combine results with weighted scoring
-            const hybridScore = {
-                native_contribution: native_weight,
-                custom_contribution: custom_weight,
-                combined_confidence: (nativeResult?.confidence || 0) * native_weight +
-                    (customResult?.confidence || 0) * custom_weight
-            };
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            status: 'success',
-                            use_case,
-                            hybrid_approach: true,
-                            native_ml_results: nativeResult,
-                            custom_nn_results: customResult,
-                            hybrid_scoring: hybridScore,
-                            recommendation: this.generateHybridRecommendation(nativeResult, customResult, hybridScore),
-                            benefits: {
-                                accuracy: 'Higher than either approach alone',
-                                robustness: 'Fallback when one system unavailable',
-                                insights: 'Complementary perspectives on data'
-                            }
-                        })
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Hybrid recommendation error:', error);
-            throw error;
-        }
-    }
-    generateHybridRecommendation(native, custom, scoring) {
-        if (scoring.combined_confidence > 0.8) {
-            return 'High confidence recommendation based on both ServiceNow ML and custom neural networks';
-        }
-        else if (native && !custom) {
-            return 'Recommendation based on ServiceNow native ML (custom models not yet trained)';
-        }
-        else if (custom && !native) {
-            return 'Recommendation based on custom neural networks (ServiceNow ML not available)';
-        }
-        else {
-            return 'Moderate confidence - consider gathering more data for improved predictions';
-        }
-    }
-    async makeServiceNowRequest(endpoint, params, method = 'GET') {
-        try {
-            // Only check ML APIs for endpoints that actually need PA/PI plugins
-            const mlAPIEndpoints = [
-                '/api/now/pa/',
-                '/api/sn_ind/',
-                '/api/now/ml/',
-                '/api/now/agent_intelligence/'
-            ];
-            const needsMLAPI = mlAPIEndpoints.some(api => endpoint.includes(api));
-            if (needsMLAPI) {
-                const hasMLAPIs = await this.checkMLAPIAvailability();
-                if (!hasMLAPIs) {
-                    throw new Error(`ServiceNow ML APIs not available. This feature requires:\n` +
-                        `- Performance Analytics (PA) plugin for KPI forecasting and analytics\n` +
-                        `- Predictive Intelligence (PI) plugin for clustering and similarity\n` +
-                        `- Agent Intelligence for AI work assignment\n` +
-                        `\nPlease ensure these plugins are activated in your ServiceNow instance.`);
-                }
-            }
-            // Make real API call to ServiceNow using the client's actual methods
-            this.logger.info(`Making ServiceNow API call: ${method} ${endpoint}`);
-            // Extract table name from endpoint if it's a table API
-            const tableMatch = endpoint.match(/\/api\/now\/table\/([\w_]+)/);
-            const statsMatch = endpoint.match(/\/api\/now\/stats\/([\w_]+)/);
-            if (method === 'GET') {
-                if (tableMatch) {
-                    // Use searchRecords for table queries
-                    const tableName = tableMatch[1];
-                    const query = params.sysparm_query || '';
-                    const limit = params.sysparm_limit || 100;
-                    this.logger.trackAPICall('SEARCH', tableName, limit);
-                    const response = await this.client.searchRecords(tableName, query, limit);
-                    if (response.success) {
-                        return {
-                            result: response.data?.result || [],
-                            data: response.data
-                        };
-                    }
-                    else {
-                        throw new Error(response.error || 'Failed to fetch records');
-                    }
-                }
-                else if (statsMatch) {
-                    // For stats API, try using aggregate query
-                    const tableName = statsMatch[1];
-                    const query = params.sysparm_query || '';
-                    // Use a limit of 1 with count to get total
-                    this.logger.trackAPICall('SEARCH', tableName, 1);
-                    const response = await this.client.searchRecords(tableName, query, 1);
-                    if (response.success) {
-                        // Estimate count based on response
-                        return {
-                            result: {
-                                stats: {
-                                    count: response.data?.result?.length >= 1 ? '1000' : '0' // Conservative estimate
-                                }
-                            }
-                        };
-                    }
-                }
-                else {
-                    // For other endpoints, use the generic get method
-                    const response = await this.client.get(endpoint, params);
-                    return response;
-                }
-            }
-            else if (method === 'POST') {
-                // For POST requests, we need to handle them differently
-                // Since ServiceNowClient doesn't have a generic POST method,
-                // we'll need to use specific methods or throw an error for unsupported operations
-                if (endpoint.includes('/api/sn_ind/') || endpoint.includes('/api/now/ml/')) {
-                    // These are ML-specific endpoints that require PA/PI
-                    throw new Error(`ML operation requires ServiceNow ML plugins (PA/PI).\n` +
-                        `Endpoint: ${endpoint}\n` +
-                        `This is a premium ServiceNow feature not available in standard instances.`);
-                }
-                // For other POST operations, try to use createRecord if it's a table operation
-                if (tableMatch) {
-                    const tableName = tableMatch[1];
-                    const response = await this.client.createRecord(tableName, params);
-                    if (response.success) {
-                        return response.data;
-                    }
-                    else {
-                        throw new Error(response.error || 'Failed to create record');
-                    }
-                }
-                else {
-                    throw new Error(`Unsupported POST operation: ${endpoint}`);
-                }
-            }
-            else {
-                throw new Error(`Unsupported HTTP method: ${method}`);
-            }
-        }
-        catch (error) {
-            this.logger.error(`ServiceNow API error for ${endpoint}:`, error.message || error);
-            throw error;
-        }
-    }
-    async checkMLAPIAvailability() {
-        // Skip the check if we already checked
-        if (this.mlAPICheckComplete) {
-            return this.hasPA || this.hasPI;
-        }
-        try {
-            let hasPA = false;
-            let hasPI = false;
-            // Check if Performance Analytics is available by trying to query PA tables
-            try {
-                const paCheck = await this.client.searchRecords('pa_indicators', '', 1);
-                if (paCheck.success) {
-                    hasPA = true;
-                    this.logger.info('✅ Performance Analytics (PA) plugin detected');
-                }
-            }
-            catch (e) {
-                // PA not available - this is expected for most instances
-                this.logger.info('ℹ️ Performance Analytics (PA) plugin not available - will use TensorFlow.js');
-            }
-            // Check if Predictive Intelligence is available by checking for PI tables
-            try {
-                const piCheck = await this.client.searchRecords('ml_capability_definition_base', '', 1);
-                if (piCheck.success) {
-                    hasPI = true;
-                    this.logger.info('✅ Predictive Intelligence (PI) plugin detected');
-                }
-            }
-            catch (e) {
-                // PI not available - this is expected for most instances
-                this.logger.info('ℹ️ Predictive Intelligence (PI) plugin not available - will use TensorFlow.js');
-            }
-            // Store availability status
-            this.hasPA = hasPA;
-            this.hasPI = hasPI;
-            this.mlAPICheckComplete = true;
-            if (!hasPA && !hasPI) {
-                this.logger.info('🤖 Using TensorFlow.js for ML operations (no ServiceNow ML plugins detected)');
-            }
-            return hasPA || hasPI;
-        }
-        catch (error) {
-            this.logger.warn('Could not check ML API availability:', error);
-            this.mlAPICheckComplete = true;
-            return false;
-        }
-    }
-    // REMOVED: generateMockMLResponse method - NO MOCK DATA
-    // All ML operations must use real ServiceNow APIs or fail with proper errors
-    async run() {
-        const transport = new stdio_js_1.StdioServerTransport();
-        await this.server.connect(transport);
-        this.logger.info('ServiceNow Machine Learning MCP server running');
-    }
-    // Helper methods for PA analysis
-    calculateForecast(paData, periods) {
-        if (!paData || !paData.scores)
-            return [];
-        // Simple linear regression forecast based on historical data
-        const scores = paData.scores.map((s) => s.value);
-        const trend = this.calculateTrend(scores);
-        const lastValue = scores[scores.length - 1] || 0;
-        return Array(periods).fill(null).map((_, i) => ({
-            period: i + 1,
-            value: lastValue + (trend * (i + 1)),
-            confidence: 0.8 - (i * 0.02) // Confidence decreases over time
-        }));
-    }
-    calculateTrend(values) {
-        if (values.length < 2)
-            return 0;
-        const n = values.length;
-        const sumX = (n * (n + 1)) / 2;
-        const sumY = values.reduce((a, b) => a + b, 0);
-        const sumXY = values.reduce((sum, y, x) => sum + (x + 1) * y, 0);
-        const sumX2 = (n * (n + 1) * (2 * n + 1)) / 6;
-        return (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
-    }
-    detectSeasonality(paData) {
-        if (!paData || !paData.scores || paData.scores.length < 14)
-            return false;
-        // Simple seasonality detection - check for weekly patterns
-        const values = paData.scores.map((s) => s.value);
-        const weeklyAvg = [];
-        for (let i = 0; i < 7; i++) {
-            const dayValues = values.filter((_, idx) => idx % 7 === i);
-            weeklyAvg.push(dayValues.reduce((a, b) => a + b, 0) / dayValues.length);
-        }
-        // Check if there's significant variance in weekly averages
-        const variance = this.calculateVariance(weeklyAvg);
-        const mean = weeklyAvg.reduce((a, b) => a + b, 0) / weeklyAvg.length;
-        return variance / mean > 0.1; // 10% coefficient of variation indicates seasonality
-    }
-    calculateVariance(values) {
-        const mean = values.reduce((a, b) => a + b, 0) / values.length;
-        const squaredDiffs = values.map(x => Math.pow(x - mean, 2));
-        return squaredDiffs.reduce((a, b) => a + b, 0) / values.length;
-    }
-    detectAnomaliesInPA(paData) {
-        if (!paData || !paData.scores)
-            return [];
-        const values = paData.scores.map((s) => s.value);
-        const mean = values.reduce((a, b) => a + b, 0) / values.length;
-        const stdDev = Math.sqrt(this.calculateVariance(values));
-        // Detect values outside 2 standard deviations
-        return paData.scores
-            .filter((score) => Math.abs(score.value - mean) > 2 * stdDev)
-            .map((score) => ({
-            date: score.date,
-            value: score.value,
-            severity: Math.abs(score.value - mean) > 3 * stdDev ? 'high' : 'medium'
-        }));
-    }
-    detectChangePoints(paData) {
-        if (!paData || !paData.scores || paData.scores.length < 10)
-            return [];
-        const values = paData.scores.map((s) => s.value);
-        const changePoints = [];
-        // Simple change point detection using moving averages
-        const windowSize = 5;
-        for (let i = windowSize; i < values.length - windowSize; i++) {
-            const before = values.slice(i - windowSize, i).reduce((a, b) => a + b, 0) / windowSize;
-            const after = values.slice(i, i + windowSize).reduce((a, b) => a + b, 0) / windowSize;
-            const change = Math.abs(after - before) / before;
-            if (change > 0.2) { // 20% change threshold
-                changePoints.push({
-                    date: paData.scores[i].date,
-                    type: after > before ? 'increase' : 'decrease',
-                    magnitude: change
-                });
-            }
-        }
-        return changePoints;
-    }
-    extractBreakdownData(scores, breakdown) {
-        if (!scores || !breakdown)
-            return null;
-        const breakdownData = {};
-        scores.forEach(score => {
-            const breakdownValue = score.breakdown || 'Unknown';
-            if (!breakdownData[breakdownValue]) {
-                breakdownData[breakdownValue] = {
-                    values: [],
-                    average: 0,
-                    trend: 0
-                };
-            }
-            breakdownData[breakdownValue].values.push(score.value);
-        });
-        // Calculate averages and trends for each breakdown
-        Object.keys(breakdownData).forEach(key => {
-            const values = breakdownData[key].values;
-            breakdownData[key].average = values.reduce((a, b) => a + b, 0) / values.length;
-            breakdownData[key].trend = this.calculateTrend(values);
-        });
-        return breakdownData;
-    }
-    generateProcessOptimizations(processData, goal) {
-        // Generate optimization recommendations based on process data
-        const recommendations = [];
-        if (processData && processData.bottlenecks) {
-            processData.bottlenecks.forEach((bottleneck) => {
-                recommendations.push({
-                    type: 'bottleneck_removal',
-                    target: bottleneck.step,
-                    impact: `${bottleneck.delay_percentage}% reduction in process time`,
-                    priority: bottleneck.delay_percentage > 20 ? 'high' : 'medium'
-                });
-            });
-        }
-        // Add goal-specific recommendations
-        switch (goal) {
-            case 'reduce_time':
-                recommendations.push({
-                    type: 'automation',
-                    target: 'Manual approval steps',
-                    impact: '40% time reduction',
-                    priority: 'high'
-                });
-                break;
-            case 'improve_quality':
-                recommendations.push({
-                    type: 'quality_gates',
-                    target: 'Add validation checkpoints',
-                    impact: '30% error reduction',
-                    priority: 'medium'
-                });
-                break;
-        }
-        return {
-            recommendations,
-            improvements: {
-                time_reduction: '25-40%',
-                quality_improvement: '20-30%',
-                cost_reduction: '15-25%'
-            },
-            steps: recommendations.map((r, i) => ({
-                order: i + 1,
-                action: r.type,
-                description: `${r.type} for ${r.target}`,
-                expected_impact: r.impact
-            })),
-            roi: {
-                investment: 'Medium',
-                payback_period: '6-9 months',
-                annual_savings: '$50,000-$100,000'
-            }
-        };
-    }
-    /**
-     * Cache a model with LRU eviction
-     * Disposes oldest model when cache is full
-     */
-    cacheModel(key, model) {
-        // If cache is full, evict oldest
-        if (this.modelCache.size >= ServiceNowMachineLearningMCP.MAX_CACHED_MODELS) {
-            const oldestKey = this.modelAccessOrder.shift();
-            if (oldestKey) {
-                const oldModel = this.modelCache.get(oldestKey);
-                if (oldModel) {
-                    oldModel.dispose();
-                    this.modelCache.delete(oldestKey);
-                    this.logger.info(`Evicted model from cache: ${oldestKey}`);
-                }
-            }
-        }
-        // Add new model
-        this.modelCache.set(key, model);
-        this.modelAccessOrder.push(key);
-    }
-    /**
-     * Get a cached model and update LRU order
-     */
-    getCachedModel(key) {
-        const model = this.modelCache.get(key);
-        if (model) {
-            // Update LRU order
-            const index = this.modelAccessOrder.indexOf(key);
-            if (index > -1) {
-                this.modelAccessOrder.splice(index, 1);
-                this.modelAccessOrder.push(key);
-            }
-        }
-        return model;
-    }
-    /**
-     * Cache an embedding with size limit
-     * Clears oldest embeddings when cache is full
-     */
-    cacheEmbedding(key, embedding) {
-        // If cache is full, clear oldest half
-        if (this.embeddingCache.size >= ServiceNowMachineLearningMCP.MAX_CACHED_EMBEDDINGS) {
-            const keysToRemove = Array.from(this.embeddingCache.keys()).slice(0, Math.floor(ServiceNowMachineLearningMCP.MAX_CACHED_EMBEDDINGS / 2));
-            for (const k of keysToRemove) {
-                const oldEmbedding = this.embeddingCache.get(k);
-                if (oldEmbedding) {
-                    oldEmbedding.dispose();
-                }
-                this.embeddingCache.delete(k);
-            }
-            this.logger.info(`Evicted ${keysToRemove.length} embeddings from cache`);
-        }
-        this.embeddingCache.set(key, embedding);
-    }
-    /**
-     * Shutdown and clean up all TensorFlow resources
-     * CRITICAL: Call this before the process exits to prevent memory leaks
-     */
-    shutdown() {
-        this.logger.info('Shutting down ML MCP server and disposing TensorFlow resources...');
-        // Dispose all cached models
-        for (const [key, model] of this.modelCache.entries()) {
-            try {
-                model.dispose();
-                this.logger.debug(`Disposed model: ${key}`);
-            }
-            catch (e) {
-                this.logger.warn(`Failed to dispose model ${key}:`, e);
-            }
-        }
-        this.modelCache.clear();
-        this.modelAccessOrder.length = 0;
-        // Dispose all cached embeddings
-        for (const [key, tensor] of this.embeddingCache.entries()) {
-            try {
-                tensor.dispose();
-            }
-            catch (e) {
-                this.logger.warn(`Failed to dispose embedding ${key}:`, e);
-            }
-        }
-        this.embeddingCache.clear();
-        // Dispose individual model instances
-        if (this.incidentClassifier) {
-            try {
-                // @ts-ignore - dispose if available
-                if (this.incidentClassifier.dispose)
-                    this.incidentClassifier.dispose();
-            }
-            catch (e) { /* ignore */ }
-        }
-        if (this.changeRiskPredictor) {
-            try {
-                // @ts-ignore
-                if (this.changeRiskPredictor.dispose)
-                    this.changeRiskPredictor.dispose();
-            }
-            catch (e) { /* ignore */ }
-        }
-        if (this.incidentVolumePredictor) {
-            try {
-                // @ts-ignore
-                if (this.incidentVolumePredictor.dispose)
-                    this.incidentVolumePredictor.dispose();
-            }
-            catch (e) { /* ignore */ }
-        }
-        if (this.anomalyDetector) {
-            try {
-                // @ts-ignore
-                if (this.anomalyDetector.dispose)
-                    this.anomalyDetector.dispose();
-            }
-            catch (e) { /* ignore */ }
-        }
-        // Log memory stats after cleanup
-        const memInfo = tf.memory();
-        this.logger.info('TensorFlow memory after cleanup:', {
-            numTensors: memInfo.numTensors,
-            numBytes: memInfo.numBytes,
-            unreliable: memInfo.unreliable
-        });
-        this.logger.info('ML MCP server shutdown complete');
-    }
-    /**
-     * Get current TensorFlow memory usage
-     */
-    getMemoryUsage() {
-        const mem = tf.memory();
-        return {
-            numTensors: mem.numTensors,
-            numBytes: mem.numBytes,
-            numDataBuffers: mem.numDataBuffers || 0
-        };
-    }
-}
-exports.ServiceNowMachineLearningMCP = ServiceNowMachineLearningMCP;
-ServiceNowMachineLearningMCP.MAX_CACHED_MODELS = 5;
-ServiceNowMachineLearningMCP.MAX_CACHED_EMBEDDINGS = 100;
-// Run the server
-if (require.main === module) {
-    const server = new ServiceNowMachineLearningMCP();
-    server.run().catch(console.error);
-}
-//# sourceMappingURL=servicenow-machine-learning-mcp.js.map