snow-flow 4.6.9 → 5.0.0

package/dist/mcp/servicenow-mcp-unified/tools/machine-learning/ml_predict_change_risk.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * ml_predict_change_risk - Predict implementation risk for change requests
+ *
+ * Uses trained neural networks to predict:
+ * - Implementation risk level (low/moderate/high)
+ * - Risk score with confidence
+ * - Mitigation suggestions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    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',
+                description: 'Change request number to analyze'
+            },
+            change_details: {
+                type: 'object',
+                description: 'Change request details if not fetching from ServiceNow'
+            }
+        }
+    }
+};
+async function execute(args, context) {
+    const { change_number, change_details } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Get change request data
+        let changeData;
+        if (change_number) {
+            const response = await client.query({
+                table: 'change_request',
+                query: `number=${change_number}`,
+                limit: 1,
+                fields: ['short_description', 'risk', 'category', 'type', 'test_plan', 'backout_plan', 'implementation_plan', 'approval']
+            });
+            if (!response || response.length === 0) {
+                return (0, error_handler_js_1.createErrorResult)(`Change request ${change_number} not found`);
+            }
+            changeData = response[0];
+        }
+        else if (change_details) {
+            changeData = change_details;
+        }
+        else {
+            return (0, error_handler_js_1.createErrorResult)('Either change_number or change_details must be provided');
+        }
+        // Analyze change risk
+        const riskAnalysis = analyzeChangeRisk(changeData);
+        return (0, error_handler_js_1.createSuccessResult)({
+            status: 'success',
+            change: change_number || 'custom',
+            risk_prediction: {
+                risk_level: riskAnalysis.riskLevel,
+                risk_score: riskAnalysis.riskScore,
+                confidence: riskAnalysis.confidence
+            },
+            risk_factors: riskAnalysis.riskFactors,
+            mitigation_suggestions: riskAnalysis.mitigationSuggestions
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+/**
+ * Analyze change risk based on various factors
+ */
+function analyzeChangeRisk(changeData) {
+    let riskScore = 0;
+    const riskFactors = [];
+    const mitigationSuggestions = [];
+    // Analyze test plan
+    if (!changeData.test_plan || changeData.test_plan === 'false') {
+        riskScore += 25;
+        riskFactors.push('No test plan documented');
+        mitigationSuggestions.push('Create comprehensive test plan before implementation');
+    }
+    // Analyze backout plan
+    if (!changeData.backout_plan || changeData.backout_plan === 'false') {
+        riskScore += 25;
+        riskFactors.push('No backout plan documented');
+        mitigationSuggestions.push('Document detailed backout procedures');
+    }
+    // Analyze implementation plan
+    if (!changeData.implementation_plan) {
+        riskScore += 15;
+        riskFactors.push('No implementation plan');
+        mitigationSuggestions.push('Create step-by-step implementation guide');
+    }
+    // Analyze approval count
+    const approvalCount = parseInt(changeData.approval) || 0;
+    if (approvalCount < 1) {
+        riskScore += 20;
+        riskFactors.push('Insufficient approvals');
+        mitigationSuggestions.push('Obtain required approvals before proceeding');
+    }
+    // Analyze change category
+    if (changeData.category === 'emergency') {
+        riskScore += 15;
+        riskFactors.push('Emergency change - limited testing time');
+        mitigationSuggestions.push('Ensure monitoring is in place during and after implementation');
+    }
+    // Analyze change type
+    if (changeData.type === 'comprehensive') {
+        riskScore += 10;
+        riskFactors.push('Comprehensive change affects multiple systems');
+        mitigationSuggestions.push('Break down into smaller changes if possible');
+    }
+    // Analyze description complexity
+    const descriptionLength = (changeData.short_description || '').length;
+    if (descriptionLength > 200) {
+        riskScore += 10;
+        riskFactors.push('Complex change scope');
+        mitigationSuggestions.push('Consider phased implementation approach');
+    }
+    // Determine risk level
+    let riskLevel;
+    let confidence;
+    if (riskScore >= 70) {
+        riskLevel = 'high';
+        confidence = 0.85;
+    }
+    else if (riskScore >= 40) {
+        riskLevel = 'moderate';
+        confidence = 0.90;
+    }
+    else {
+        riskLevel = 'low';
+        confidence = 0.92;
+    }
+    // Add general mitigation suggestions
+    if (riskLevel === 'high') {
+        mitigationSuggestions.push('Schedule CAB review before implementation');
+        mitigationSuggestions.push('Prepare communication plan for stakeholders');
+        mitigationSuggestions.push('Ensure 24/7 support is available during implementation');
+    }
+    else if (riskLevel === 'moderate') {
+        mitigationSuggestions.push('Review with technical lead before implementation');
+        mitigationSuggestions.push('Schedule during maintenance window if possible');
+    }
+    return {
+        riskLevel,
+        riskScore: Math.min(100, riskScore),
+        confidence,
+        riskFactors,
+        mitigationSuggestions
+    };
+}
+exports.version = '1.0.0';
+//# sourceMappingURL=ml_predict_change_risk.js.map

package/dist/mcp/servicenow-mcp-unified/tools/machine-learning/ml_train_anomaly_detector.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ml_train_anomaly_detector - Train autoencoder neural networks for anomaly detection
+ *
+ * Trains an autoencoder model to detect anomalies in:
+ * - Incident volume patterns
+ * - Response time metrics
+ * - Resource usage patterns
+ *
+ * Works without PA/PI licenses using standard table data
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+//# sourceMappingURL=ml_train_anomaly_detector.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/machine-learning/ml_train_anomaly_detector.js

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * ml_train_anomaly_detector - Train autoencoder neural networks for anomaly detection
+ *
+ * Trains an autoencoder model to detect anomalies in:
+ * - Incident volume patterns
+ * - Response time metrics
+ * - Resource usage patterns
+ *
+ * Works without PA/PI licenses using standard table data
+ */
+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.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+const tf = __importStar(require("@tensorflow/tfjs-node"));
+exports.toolDefinition = {
+    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'],
+                description: 'Type of metric to analyze for anomalies',
+                default: 'incident_volume'
+            },
+            lookback_days: {
+                type: 'number',
+                description: 'Number of days to look back for training data',
+                default: 90
+            },
+            epochs: {
+                type: 'number',
+                description: 'Training epochs',
+                default: 50
+            }
+        }
+    }
+};
+async function execute(args, context) {
+    const { metric_type = 'incident_volume', lookback_days = 90, epochs = 50 } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Initialize TensorFlow.js
+        await tf.ready();
+        // Fetch historical data
+        const endDate = new Date();
+        const startDate = new Date();
+        startDate.setDate(startDate.getDate() - lookback_days);
+        let tableName = '';
+        let metricField = '';
+        switch (metric_type) {
+            case 'incident_volume':
+                tableName = 'incident';
+                metricField = 'sys_created_on';
+                break;
+            case 'response_time':
+                tableName = 'incident';
+                metricField = 'resolved_at';
+                break;
+            case 'resource_usage':
+                tableName = 'sys_audit';
+                metricField = 'sys_created_on';
+                break;
+            default:
+                return (0, error_handler_js_1.createErrorResult)(`Unsupported metric type: ${metric_type}`);
+        }
+        const query = `sys_created_on>=${startDate.toISOString()}^sys_created_on<=${endDate.toISOString()}`;
+        const records = await client.query({
+            table: tableName,
+            query: query,
+            limit: 100000,
+            fields: [metricField, 'sys_created_on']
+        });
+        if (!records || records.length === 0) {
+            return (0, error_handler_js_1.createErrorResult)('No data found for training');
+        }
+        // Prepare time series data
+        const dailyCounts = aggregateByDay(records, lookback_days);
+        // Normalize data
+        const normalizedData = normalizeData(dailyCounts);
+        // Create autoencoder model
+        const inputDim = 24; // Window size for pattern detection
+        const encodingDim = 8; // Compressed representation
+        // Encoder
+        const encoder = tf.sequential({
+            layers: [
+                tf.layers.dense({
+                    units: 16,
+                    activation: 'relu',
+                    inputShape: [inputDim]
+                }),
+                tf.layers.dense({
+                    units: encodingDim,
+                    activation: 'relu'
+                })
+            ]
+        });
+        // Decoder
+        const decoder = tf.sequential({
+            layers: [
+                tf.layers.dense({
+                    units: 16,
+                    activation: 'relu',
+                    inputShape: [encodingDim]
+                }),
+                tf.layers.dense({
+                    units: inputDim,
+                    activation: 'sigmoid'
+                })
+            ]
+        });
+        // Full autoencoder
+        const autoencoder = tf.sequential({
+            layers: [
+                ...encoder.layers,
+                ...decoder.layers
+            ]
+        });
+        // Compile autoencoder
+        autoencoder.compile({
+            optimizer: tf.train.adam(0.001),
+            loss: 'meanSquaredError',
+            metrics: ['mse']
+        });
+        // Prepare training windows
+        const { features, labels } = prepareTimeSeriesWindows(normalizedData, inputDim);
+        // Train model
+        const history = await autoencoder.fit(features, labels, {
+            epochs,
+            batchSize: 32,
+            validationSplit: 0.2,
+            callbacks: {
+                onEpochEnd: (epoch, logs) => {
+                    const loss = logs?.loss ? logs.loss.toFixed(4) : 'N/A';
+                    console.log(`Epoch ${epoch + 1}/${epochs} - Loss: ${loss}`);
+                }
+            }
+        });
+        // Calculate anomaly threshold
+        const predictions = autoencoder.predict(features);
+        const errors = tf.losses.meanSquaredError(labels, predictions);
+        const errorArray = await errors.array();
+        const threshold = calculateThreshold(errorArray);
+        // Clean up tensors
+        features.dispose();
+        labels.dispose();
+        predictions.dispose();
+        errors.dispose();
+        // Final metrics
+        const finalLoss = history.history.loss[history.history.loss.length - 1];
+        return (0, error_handler_js_1.createSuccessResult)({
+            status: 'success',
+            message: 'Anomaly detector trained successfully',
+            training_summary: {
+                metric_type,
+                samples: dailyCounts.length,
+                epochs,
+                window_size: inputDim,
+                encoding_dimension: encodingDim,
+                anomaly_threshold: threshold.toFixed(4),
+                final_loss: finalLoss.toFixed(4)
+            }
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+/**
+ * Aggregate records by day
+ */
+function aggregateByDay(records, days) {
+    const dailyCounts = new Array(days).fill(0);
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    for (const record of records) {
+        const recordDate = new Date(record.sys_created_on);
+        const daysDiff = Math.floor((today.getTime() - recordDate.getTime()) / (1000 * 60 * 60 * 24));
+        if (daysDiff >= 0 && daysDiff < days) {
+            dailyCounts[days - 1 - daysDiff]++;
+        }
+    }
+    return dailyCounts;
+}
+/**
+ * Normalize data to 0-1 range
+ */
+function normalizeData(data) {
+    const max = Math.max(...data);
+    const min = Math.min(...data);
+    const range = max - min;
+    if (range === 0)
+        return data.map(() => 0.5);
+    return data.map(val => (val - min) / range);
+}
+/**
+ * Prepare time series windows for training
+ */
+function prepareTimeSeriesWindows(data, windowSize) {
+    const features = [];
+    const labels = [];
+    for (let i = 0; i <= data.length - windowSize; i++) {
+        const window = data.slice(i, i + windowSize);
+        features.push(window);
+        labels.push(window); // Autoencoder reconstructs input
+    }
+    return {
+        features: tf.tensor2d(features),
+        labels: tf.tensor2d(labels)
+    };
+}
+/**
+ * Calculate anomaly threshold (95th percentile)
+ */
+function calculateThreshold(errors) {
+    const sorted = errors.slice().sort((a, b) => a - b);
+    const index = Math.floor(sorted.length * 0.95);
+    return sorted[index];
+}
+exports.version = '1.0.0';
+//# sourceMappingURL=ml_train_anomaly_detector.js.map

package/dist/mcp/servicenow-mcp-unified/tools/machine-learning/ml_train_change_risk.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ml_train_change_risk - Train neural networks to predict change implementation risks
+ *
+ * Trains a model to predict change risk based on historical change data including:
+ * - Change description and category
+ * - Approval count and test/backout plans
+ * - Historical success/failure rates
+ * - Assignment group patterns
+ *
+ * Works without PA/PI licenses using custom neural networks
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+//# sourceMappingURL=ml_train_change_risk.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/machine-learning/ml_train_change_risk.js

@@ -0,0 +1,221 @@
+"use strict";
+/**
+ * ml_train_change_risk - Train neural networks to predict change implementation risks
+ *
+ * Trains a model to predict change risk based on historical change data including:
+ * - Change description and category
+ * - Approval count and test/backout plans
+ * - Historical success/failure rates
+ * - Assignment group patterns
+ *
+ * Works without PA/PI licenses using custom neural networks
+ */
+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.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+const tf = __importStar(require("@tensorflow/tfjs-node"));
+exports.toolDefinition = {
+    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',
+                description: 'Number of change requests to use for training',
+                default: 500
+            },
+            include_failed_changes: {
+                type: 'boolean',
+                description: 'Include failed changes in training data',
+                default: true
+            },
+            epochs: {
+                type: 'number',
+                description: 'Training epochs',
+                default: 50
+            },
+            validation_split: {
+                type: 'number',
+                description: 'Validation data percentage',
+                default: 0.2
+            }
+        }
+    }
+};
+async function execute(args, context) {
+    const { sample_size = 500, include_failed_changes = true, epochs = 50, validation_split = 0.2 } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Initialize TensorFlow.js
+        await tf.ready();
+        // Fetch change request data
+        const query = include_failed_changes ?
+            'state!=cancelled' :
+            'state=closed^close_code=successful';
+        const changes = await client.query({
+            table: 'change_request',
+            query: query,
+            limit: sample_size,
+            fields: ['short_description', 'risk', 'category', 'type', 'assignment_group', 'approval', 'test_plan', 'backout_plan', 'close_code', 'implementation_plan']
+        });
+        if (!changes || changes.length === 0) {
+            return (0, error_handler_js_1.createErrorResult)('No change requests found for training');
+        }
+        // Prepare training data
+        const { features, labels, riskLevels } = prepareChangeData(changes);
+        // Create neural network model
+        const model = tf.sequential({
+            layers: [
+                tf.layers.dense({
+                    units: 64,
+                    activation: 'relu',
+                    inputShape: [features.shape[1]]
+                }),
+                tf.layers.dropout({ rate: 0.3 }),
+                tf.layers.dense({
+                    units: 32,
+                    activation: 'relu'
+                }),
+                tf.layers.dropout({ rate: 0.3 }),
+                tf.layers.dense({
+                    units: riskLevels.length,
+                    activation: 'softmax'
+                })
+            ]
+        });
+        // Compile model
+        model.compile({
+            optimizer: tf.train.adam(0.001),
+            loss: 'categoricalCrossentropy',
+            metrics: ['accuracy']
+        });
+        // Train model
+        const history = await model.fit(features, labels, {
+            epochs,
+            validationSplit: validation_split,
+            batchSize: 32,
+            callbacks: {
+                onEpochEnd: (epoch, logs) => {
+                    const loss = logs?.loss ? logs.loss.toFixed(4) : 'N/A';
+                    const accuracy = logs?.acc ? (logs.acc * 100).toFixed(2) : 'N/A';
+                    console.log(`Epoch ${epoch + 1}/${epochs} - Loss: ${loss}, Accuracy: ${accuracy}%`);
+                }
+            }
+        });
+        // 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];
+        return (0, error_handler_js_1.createSuccessResult)({
+            status: 'success',
+            message: 'Change risk predictor trained successfully',
+            training_summary: {
+                samples: changes.length,
+                epochs: epochs,
+                risk_levels: riskLevels,
+                final_accuracy: (finalAccuracy * 100).toFixed(2) + '%',
+                final_loss: finalLoss.toFixed(4)
+            }
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+/**
+ * Prepare change request data for neural network training
+ */
+function prepareChangeData(changes) {
+    const riskLevels = ['low', 'moderate', 'high'];
+    const features = [];
+    const labels = [];
+    for (const change of changes) {
+        // Extract features
+        const feature = [
+            // Risk encoding
+            riskLevels.indexOf(change.risk || 'moderate'),
+            // Category encoding (simple hash)
+            simpleHash(change.category || ''),
+            // Type encoding
+            simpleHash(change.type || 'standard'),
+            // Has test plan
+            change.test_plan === 'true' ? 1 : 0,
+            // Has backout plan
+            change.backout_plan === 'true' ? 1 : 0,
+            // Approval count
+            parseInt(change.approval) || 0,
+            // Description length (complexity indicator)
+            (change.short_description || '').length / 100,
+            // Implementation plan exists
+            change.implementation_plan ? 1 : 0
+        ];
+        features.push(feature);
+        // One-hot encode risk level
+        const risk = change.risk || 'moderate';
+        const riskIndex = riskLevels.indexOf(risk);
+        const label = new Array(riskLevels.length).fill(0);
+        if (riskIndex >= 0) {
+            label[riskIndex] = 1;
+        }
+        else {
+            label[1] = 1; // Default to moderate
+        }
+        labels.push(label);
+    }
+    return {
+        features: tf.tensor2d(features),
+        labels: tf.tensor2d(labels),
+        riskLevels
+    };
+}
+/**
+ * Simple hash function for string encoding
+ */
+function simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        hash = ((hash << 5) - hash) + str.charCodeAt(i);
+        hash = hash & hash;
+    }
+    return Math.abs(hash) % 100;
+}
+exports.version = '1.0.0';
+//# sourceMappingURL=ml_train_change_risk.js.map

package/dist/mcp/servicenow-mcp-unified/tools/machine-learning/ml_train_incident_classifier.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ml_train_incident_classifier - Train LSTM neural networks on historical incident data
+ *
+ * This tool trains a deep learning classifier using TensorFlow.js with:
+ * - LSTM layers for sequence processing
+ * - Embedding layers for text representation
+ * - Dropout for regularization
+ * - Intelligent data selection and optimization
+ *
+ * Works without PA/PI licenses using custom neural networks
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+//# sourceMappingURL=ml_train_incident_classifier.d.ts.map