@mxf-dev/core 1.0.0

package/dist/services/AutoCorrectionService.js

@@ -0,0 +1,822 @@
+/**
+ * Copyright 2024 Brad Anderson
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @author Brad Anderson <BradA1878@pm.me>
+ * @repository https://github.com/mxf-dev/mxf
+ * @documentation https://mxf-dev.github.io/mxf/
+ */
+/**
+ * AutoCorrectionService - Phase 4 Auto-Correction System
+ *
+ * Orchestrates automatic correction of tool execution errors using:
+ * - ValidationPerformanceService for error analysis
+ * - PatternLearningService for correction strategies
+ * - Machine learning-based error pattern recognition
+ * - Retry logic with exponential backoff
+ * - Safety constraints to prevent infinite loops
+ */
+import { v4 as uuidv4 } from 'uuid';
+import { Subject } from 'rxjs';
+import { Logger } from '../utils/Logger.js';
+import { EventBus } from '../events/EventBus.js';
+import { Events } from '../events/EventNames.js';
+import { ValidationPerformanceService } from './ValidationPerformanceService.js';
+import { PatternLearningService } from './PatternLearningService.js';
+/**
+ * Auto-correction service for orchestrating automatic error correction
+ */
+export class AutoCorrectionService {
+    logger;
+    validationService;
+    patternService;
+    // Correction tracking
+    correctionAttempts = new Map();
+    retryTimers = new Map();
+    // Events
+    correctionEvents$ = new Subject();
+    // Configuration
+    config;
+    // Correction strategies
+    strategies = new Map();
+    // Separate instances for client and server contexts
+    static serverInstance;
+    static clientInstance;
+    constructor(isClient = false) {
+        const context = isClient ? 'client' : 'server';
+        this.logger = new Logger('info', 'AutoCorrectionService', context);
+        this.validationService = ValidationPerformanceService.getInstance();
+        this.patternService = PatternLearningService.getInstance();
+        this.config = this.getDefaultConfig();
+        this.initializeStrategies();
+        this.setupEventListeners();
+    }
+    /**
+     * Get singleton instance for the specified context
+     * @param isClient Whether this is for client-side logging (default: false for server)
+     */
+    static getInstance(isClient = false) {
+        if (isClient) {
+            if (!AutoCorrectionService.clientInstance) {
+                AutoCorrectionService.clientInstance = new AutoCorrectionService(true);
+            }
+            return AutoCorrectionService.clientInstance;
+        }
+        else {
+            if (!AutoCorrectionService.serverInstance) {
+                AutoCorrectionService.serverInstance = new AutoCorrectionService(false);
+            }
+            return AutoCorrectionService.serverInstance;
+        }
+    }
+    // =============================================================================
+    // CORE AUTO-CORRECTION METHODS
+    // =============================================================================
+    /**
+     * Attempt to automatically correct a failed tool execution
+     */
+    async attemptCorrection(agentId, channelId, toolName, originalParameters, errorMessage, toolSchema) {
+        if (!this.config.enabled) {
+            return { corrected: false, shouldRetry: false };
+        }
+        const correctionKey = `${agentId}:${channelId}:${toolName}`;
+        const existingAttempts = this.correctionAttempts.get(correctionKey) || [];
+        // Check if we've exceeded max retry attempts
+        if (existingAttempts.length >= this.config.maxRetryAttempts) {
+            this.logger.warn(`Max retry attempts (${this.config.maxRetryAttempts}) exceeded for ${toolName}`);
+            return { corrected: false, shouldRetry: false };
+        }
+        const attemptId = `${uuidv4()}`;
+        try {
+            // Find the best correction strategy
+            const bestStrategy = await this.findBestCorrectionStrategy(toolName, originalParameters, errorMessage, toolSchema);
+            if (!bestStrategy || bestStrategy.confidence < this.config.confidenceThreshold) {
+                // Store failed attempt
+                const failedAttempt = {
+                    attemptId,
+                    timestamp: Date.now(),
+                    agentId,
+                    channelId,
+                    toolName,
+                    originalParameters,
+                    correctedParameters: originalParameters,
+                    strategy: bestStrategy?.type || 'unknown_properties',
+                    confidence: bestStrategy?.confidence || 0,
+                    successful: false,
+                    errorMessage: 'No suitable correction strategy found'
+                };
+                this.recordCorrectionAttempt(correctionKey, failedAttempt);
+                return {
+                    corrected: false,
+                    shouldRetry: false,
+                    attemptId
+                };
+            }
+            // Apply the correction
+            const correctedParameters = await this.applyCorrectionStrategy(bestStrategy.type, toolName, originalParameters, errorMessage, toolSchema);
+            if (!correctedParameters) {
+                this.logger.warn(`Correction strategy ${bestStrategy.type} failed to generate parameters`);
+                return { corrected: false, shouldRetry: false, attemptId };
+            }
+            // Create correction attempt record
+            const attempt = {
+                attemptId,
+                timestamp: Date.now(),
+                agentId,
+                channelId,
+                toolName,
+                originalParameters,
+                correctedParameters,
+                strategy: bestStrategy.type,
+                confidence: bestStrategy.confidence,
+                successful: false // Will be updated when we know the result
+            };
+            this.recordCorrectionAttempt(correctionKey, attempt);
+            // Calculate retry delay
+            const retryDelay = this.calculateRetryDelay(existingAttempts.length);
+            return {
+                corrected: true,
+                correctedParameters,
+                strategy: bestStrategy.type,
+                confidence: bestStrategy.confidence,
+                attemptId,
+                shouldRetry: true,
+                retryDelay
+            };
+        }
+        catch (error) {
+            this.logger.error(`Auto-correction failed for ${toolName}:`, error);
+            return { corrected: false, shouldRetry: false, attemptId };
+        }
+    }
+    /**
+     * Report the result of a correction attempt
+     */
+    async reportCorrectionResult(attemptId, successful, errorMessage, executionTime) {
+        // Find the attempt across all correction keys
+        let foundAttempt;
+        let correctionKey;
+        for (const [key, attempts] of this.correctionAttempts.entries()) {
+            foundAttempt = attempts.find(a => a.attemptId === attemptId);
+            if (foundAttempt) {
+                correctionKey = key;
+                break;
+            }
+        }
+        if (!foundAttempt || !correctionKey) {
+            this.logger.warn(`Correction attempt ${attemptId} not found`);
+            return;
+        }
+        // Update the attempt
+        foundAttempt.successful = successful;
+        foundAttempt.errorMessage = errorMessage;
+        foundAttempt.recoveryTime = executionTime;
+        // Emit correction event
+        this.correctionEvents$.next(foundAttempt);
+        if (successful) {
+            // Learn from successful correction if enabled
+            if (this.config.learnFromSuccessfulCorrections) {
+                await this.learnFromSuccessfulCorrection(foundAttempt);
+            }
+            // Clear retry timer if exists
+            const timer = this.retryTimers.get(correctionKey);
+            if (timer) {
+                clearTimeout(timer);
+                this.retryTimers.delete(correctionKey);
+            }
+        }
+        else {
+            this.logger.warn(`❌ Auto-correction failed for ${foundAttempt.toolName}: ${errorMessage}`);
+        }
+        // Audit the attempt if enabled
+        if (this.config.auditAllAttempts) {
+            await this.auditCorrectionAttempt(foundAttempt);
+        }
+    }
+    // =============================================================================
+    // CORRECTION STRATEGY METHODS
+    // =============================================================================
+    /**
+     * Find the best correction strategy for a given error
+     */
+    async findBestCorrectionStrategy(toolName, parameters, errorMessage, toolSchema) {
+        const strategies = [];
+        // Evaluate each enabled strategy
+        for (const strategyType of this.config.enabledStrategies) {
+            const strategy = this.strategies.get(strategyType);
+            if (!strategy)
+                continue;
+            try {
+                const result = await strategy.analyze(toolName, parameters, errorMessage, toolSchema);
+                if (result.canCorrect) {
+                    strategies.push({
+                        type: strategyType,
+                        confidence: result.confidence,
+                        suggestedCorrection: result.suggestedCorrection,
+                        reasoning: result.reasoning
+                    });
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Strategy ${strategyType} analysis failed:`, error);
+            }
+        }
+        // Return the highest confidence strategy
+        return strategies.length > 0
+            ? strategies.sort((a, b) => b.confidence - a.confidence)[0]
+            : null;
+    }
+    /**
+     * Apply a specific correction strategy
+     */
+    async applyCorrectionStrategy(strategyType, toolName, originalParameters, errorMessage, toolSchema) {
+        const strategy = this.strategies.get(strategyType);
+        if (!strategy) {
+            this.logger.error(`Strategy ${strategyType} not found`);
+            return null;
+        }
+        try {
+            const result = await strategy.analyze(toolName, originalParameters, errorMessage, toolSchema);
+            return result.suggestedCorrection || null;
+        }
+        catch (error) {
+            this.logger.error(`Failed to apply strategy ${strategyType}:`, error);
+            return null;
+        }
+    }
+    // =============================================================================
+    // CORRECTION STRATEGIES IMPLEMENTATION
+    // =============================================================================
+    /**
+     * Initialize correction strategies
+     */
+    initializeStrategies() {
+        // Missing Required Parameters Strategy
+        this.strategies.set('missing_required', {
+            type: 'missing_required',
+            analyze: async (toolName, parameters, errorMessage, toolSchema) => {
+                if (!errorMessage.toLowerCase().includes('required') &&
+                    !errorMessage.toLowerCase().includes('missing')) {
+                    return { canCorrect: false, confidence: 0 };
+                }
+                // Try to get successful patterns for this tool
+                // Uses 'default' channel since strategy context doesn't include channel info
+                // Patterns are aggregated across channels for global learning
+                try {
+                    const patterns = await this.patternService.getEnhancedPatterns('default', toolName, true);
+                    if (patterns.successful.length > 0) {
+                        // Use the most successful pattern
+                        const bestPattern = patterns.successful
+                            .sort((a, b) => b.confidenceScore - a.confidenceScore)[0];
+                        // Merge with original parameters, prioritizing pattern values for missing keys
+                        const corrected = { ...parameters };
+                        for (const [key, value] of Object.entries(bestPattern.parameters)) {
+                            if (!(key in corrected)) {
+                                corrected[key] = value;
+                            }
+                        }
+                        return {
+                            canCorrect: true,
+                            confidence: bestPattern.confidenceScore * 0.9, // Slight penalty
+                            suggestedCorrection: corrected,
+                            reasoning: `Added missing parameters from successful pattern (used ${bestPattern.frequency} times)`
+                        };
+                    }
+                }
+                catch (error) {
+                }
+                return { canCorrect: false, confidence: 0 };
+            }
+        });
+        // Parameter Name Strategy (with n8n-specific mappings + pattern-based fallback)
+        this.strategies.set('wrong_parameter_names', {
+            type: 'wrong_parameter_names',
+            analyze: async (toolName, parameters, errorMessage, toolSchema) => {
+                if (!errorMessage.toLowerCase().includes('unknown') &&
+                    !errorMessage.toLowerCase().includes('additional') &&
+                    !errorMessage.toLowerCase().includes('required') &&
+                    !errorMessage.toLowerCase().includes('missing')) {
+                    return { canCorrect: false, confidence: 0 };
+                }
+                // n8n-specific parameter mapping for workflow tools
+                if (toolName === 'create_workflow' || toolName === 'update_workflow' || toolName.includes('workflow')) {
+                    const corrected = JSON.parse(JSON.stringify(parameters)); // Deep copy
+                    let correctionCount = 0;
+                    // n8n Data Table node parameter mappings
+                    const n8nMappings = {
+                        'tableName': 'dataTable', // Wrong → Right
+                        'table': 'dataTable',
+                        'insert': 'insertRow',
+                        'data': 'dataFields',
+                        'fields': 'dataFields'
+                    };
+                    // Check if this is a workflow with nodes array
+                    if (corrected.nodes && Array.isArray(corrected.nodes)) {
+                        corrected.nodes = corrected.nodes.map((node) => {
+                            // Only fix Data Table nodes
+                            if (node.type === 'n8n-nodes-base.dataTable' && node.parameters) {
+                                const oldParams = { ...node.parameters };
+                                const newParams = {};
+                                // Map old parameter names to correct ones
+                                for (const [key, value] of Object.entries(oldParams)) {
+                                    const correctKey = n8nMappings[key] || key;
+                                    newParams[correctKey] = value;
+                                    if (correctKey !== key) {
+                                        correctionCount++;
+                                    }
+                                }
+                                return { ...node, parameters: newParams };
+                            }
+                            return node;
+                        });
+                    }
+                    if (correctionCount > 0) {
+                        return {
+                            canCorrect: true,
+                            confidence: 0.95, // High confidence for known n8n mappings
+                            suggestedCorrection: corrected,
+                            reasoning: `Corrected ${correctionCount} n8n Data Table parameter name(s) to match API requirements (e.g., tableName→dataTable, insert→insertRow, data→dataFields)`
+                        };
+                    }
+                }
+                // Fallback to pattern-based correction
+                try {
+                    const patterns = await this.patternService.getEnhancedPatterns('default', toolName, true);
+                    if (patterns.successful.length > 0) {
+                        const bestPattern = patterns.successful[0];
+                        const patternKeys = Object.keys(bestPattern.parameters);
+                        const currentKeys = Object.keys(parameters);
+                        // Look for similar key names (fuzzy matching)
+                        const corrected = { ...bestPattern.parameters };
+                        let matchCount = 0;
+                        for (const currentKey of currentKeys) {
+                            for (const patternKey of patternKeys) {
+                                if (this.areKeysSimilar(currentKey, patternKey)) {
+                                    corrected[patternKey] = parameters[currentKey];
+                                    matchCount++;
+                                    break;
+                                }
+                            }
+                        }
+                        if (matchCount > 0) {
+                            return {
+                                canCorrect: true,
+                                confidence: (matchCount / currentKeys.length) * 0.8,
+                                suggestedCorrection: corrected,
+                                reasoning: `Corrected ${matchCount} parameter names using successful pattern`
+                            };
+                        }
+                    }
+                }
+                catch (error) {
+                }
+                return { canCorrect: false, confidence: 0 };
+            }
+        });
+        // Type Mismatch Strategy (Enhanced with JSON string to object conversion)
+        this.strategies.set('type_mismatch', {
+            type: 'type_mismatch',
+            analyze: async (toolName, parameters, errorMessage, toolSchema) => {
+                // Enhanced error detection to catch more type-related errors - make it more lenient
+                const errorLower = errorMessage.toLowerCase();
+                const hasTypeError = errorLower.includes('type') ||
+                    errorLower.includes('expected') ||
+                    errorLower.includes('must be') ||
+                    errorLower.includes('should be') ||
+                    errorLower.includes('invalid') ||
+                    errorLower.includes('validation') ||
+                    errorLower.includes('schema') ||
+                    errorLower.includes('format') ||
+                    errorLower.includes('property') ||
+                    errorLower.includes('boolean') ||
+                    errorLower.includes('object') ||
+                    errorLower.includes('string') ||
+                    errorLower.includes('number') ||
+                    errorLower.includes('required') ||
+                    errorLower.includes('missing') ||
+                    errorLower.includes('data') ||
+                    errorLower.includes('instance');
+                if (!hasTypeError) {
+                    return { canCorrect: false, confidence: 0 };
+                }
+                // Special handling for common task_complete errors
+                if (toolName === 'task_complete') {
+                    const corrected = { ...parameters };
+                    let correctionCount = 0;
+                    // Handle success parameter - convert string "true"/"false" to boolean
+                    if ('success' in corrected && typeof corrected.success === 'string') {
+                        const successStr = corrected.success.toLowerCase().trim();
+                        if (successStr === 'true' || successStr === '1' || successStr === 'yes') {
+                            corrected.success = true;
+                            correctionCount++;
+                        }
+                        else if (successStr === 'false' || successStr === '0' || successStr === 'no') {
+                            corrected.success = false;
+                            correctionCount++;
+                        }
+                    }
+                    // Handle details parameter - convert JSON string to object
+                    if ('details' in corrected && typeof corrected.details === 'string') {
+                        try {
+                            const parsed = JSON.parse(corrected.details);
+                            if (typeof parsed === 'object' && parsed !== null) {
+                                corrected.details = parsed;
+                                correctionCount++;
+                            }
+                        }
+                        catch (error) {
+                            // If not valid JSON, create a simple object with the string as a field
+                            corrected.details = { description: corrected.details };
+                            correctionCount++;
+                        }
+                    }
+                    if (correctionCount > 0) {
+                        return {
+                            canCorrect: true,
+                            confidence: 0.95, // High confidence for task_complete corrections
+                            suggestedCorrection: corrected,
+                            reasoning: `Fixed ${correctionCount} type issue(s) in task_complete: converted string values to proper types for validation`
+                        };
+                    }
+                }
+                const corrected = { ...parameters };
+                let correctionCount = 0;
+                let schemaBasedCorrections = 0;
+                // First, try to use the tool schema if available
+                if (toolSchema && toolSchema.properties) {
+                    for (const [key, schema] of Object.entries(toolSchema.properties)) {
+                        if (key in corrected && schema.type) {
+                            const currentType = typeof corrected[key];
+                            const expectedType = schema.type;
+                            // Check if type conversion is needed
+                            if ((expectedType === 'object' && currentType === 'string') ||
+                                (expectedType === 'array' && currentType === 'string') ||
+                                (expectedType === 'number' && currentType === 'string') ||
+                                (expectedType === 'boolean' && currentType === 'string') ||
+                                (expectedType === 'string' && currentType !== 'string')) {
+                                try {
+                                    corrected[key] = this.convertType(corrected[key], expectedType);
+                                    correctionCount++;
+                                    schemaBasedCorrections++;
+                                }
+                                catch (error) {
+                                }
+                            }
+                        }
+                    }
+                }
+                // If no schema-based corrections, try pattern-based corrections
+                if (correctionCount === 0) {
+                    try {
+                        const patterns = await this.patternService.getEnhancedPatterns('default', toolName, true);
+                        if (patterns.successful.length > 0) {
+                            const bestPattern = patterns.successful[0];
+                            // Try to match types from successful patterns
+                            for (const [key, value] of Object.entries(bestPattern.parameters)) {
+                                if (key in corrected && typeof corrected[key] !== typeof value) {
+                                    try {
+                                        corrected[key] = this.convertType(corrected[key], typeof value);
+                                        correctionCount++;
+                                    }
+                                    catch (error) {
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    catch (error) {
+                    }
+                }
+                if (correctionCount > 0) {
+                    const reasoning = schemaBasedCorrections > 0
+                        ? `Corrected ${correctionCount} type mismatches using tool schema (including JSON string to object conversions)`
+                        : `Corrected ${correctionCount} type mismatches using successful pattern`;
+                    return {
+                        canCorrect: true,
+                        confidence: schemaBasedCorrections > 0 ? 0.9 : 0.7,
+                        suggestedCorrection: corrected,
+                        reasoning
+                    };
+                }
+                return { canCorrect: false, confidence: 0 };
+            }
+        });
+        // Pattern-Based Strategy (uses ML insights)
+        this.strategies.set('pattern_based', {
+            type: 'pattern_based',
+            analyze: async (toolName, parameters, errorMessage, toolSchema) => {
+                try {
+                    // Get pattern recommendations
+                    const recommendations = await this.patternService.getPatternRecommendations('system', 'default', toolName, parameters);
+                    if (recommendations.length > 0) {
+                        const bestRecommendation = recommendations[0];
+                        return {
+                            canCorrect: true,
+                            confidence: bestRecommendation.confidence * bestRecommendation.relevanceScore,
+                            suggestedCorrection: bestRecommendation.pattern.parameters,
+                            reasoning: bestRecommendation.reason
+                        };
+                    }
+                }
+                catch (error) {
+                }
+                return { canCorrect: false, confidence: 0 };
+            }
+        });
+        // JSON String Correction Strategy (for common LLM mistake)
+        this.strategies.set('json_string_conversion', {
+            type: 'json_string_conversion',
+            analyze: async (toolName, parameters, errorMessage, toolSchema) => {
+                // Detect JSON string errors - expanded to catch more validation patterns
+                const errorLower = errorMessage.toLowerCase();
+                if (!errorLower.includes('must be object') &&
+                    !errorLower.includes('must be array') &&
+                    !errorLower.includes('expected object') &&
+                    !errorLower.includes('expected array') &&
+                    !errorLower.includes('should be object') &&
+                    !errorLower.includes('should be array') &&
+                    !errorLower.includes('instance type') &&
+                    !errorLower.includes('data type') &&
+                    !errorLower.includes('invalid type') &&
+                    !errorLower.includes('validation failed') &&
+                    !errorLower.includes('schema validation')) {
+                    return { canCorrect: false, confidence: 0 };
+                }
+                const corrected = { ...parameters };
+                let correctionCount = 0;
+                const corrections = [];
+                // Check each parameter for JSON strings that should be objects/arrays
+                for (const [key, value] of Object.entries(parameters)) {
+                    if (typeof value === 'string') {
+                        // Check if this looks like JSON
+                        const trimmed = value.trim();
+                        if ((trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+                            (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+                            try {
+                                const parsed = JSON.parse(value);
+                                if (typeof parsed === 'object' && parsed !== null) {
+                                    corrected[key] = parsed;
+                                    correctionCount++;
+                                    corrections.push(`${key}: string → ${Array.isArray(parsed) ? 'array' : 'object'}`);
+                                }
+                            }
+                            catch (error) {
+                                // Not valid JSON, skip
+                            }
+                        }
+                    }
+                }
+                if (correctionCount > 0) {
+                    return {
+                        canCorrect: true,
+                        confidence: 0.95, // High confidence for this specific pattern
+                        suggestedCorrection: corrected,
+                        reasoning: `Converted ${correctionCount} JSON string(s) to object(s): ${corrections.join(', ')}. This is a common LLM mistake where objects are stringified unnecessarily.`
+                    };
+                }
+                return { canCorrect: false, confidence: 0 };
+            }
+        });
+    }
+    // =============================================================================
+    // HELPER METHODS
+    // =============================================================================
+    /**
+     * Check if two parameter keys are similar (for fuzzy matching)
+     */
+    areKeysSimilar(key1, key2) {
+        if (key1 === key2)
+            return true;
+        // Simple similarity checks
+        const normalized1 = key1.toLowerCase().replace(/[_-]/g, '');
+        const normalized2 = key2.toLowerCase().replace(/[_-]/g, '');
+        if (normalized1 === normalized2)
+            return true;
+        // Check if one contains the other
+        if (normalized1.includes(normalized2) || normalized2.includes(normalized1)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Convert value to target type
+     */
+    convertType(value, targetType) {
+        switch (targetType) {
+            case 'string':
+                return String(value);
+            case 'number':
+                const num = Number(value);
+                if (isNaN(num))
+                    throw new Error(`Cannot convert ${value} to number`);
+                return num;
+            case 'boolean':
+                if (typeof value === 'boolean')
+                    return value;
+                if (typeof value === 'string') {
+                    const lowerValue = value.toLowerCase().trim();
+                    // More aggressive string-to-boolean conversion for common LLM mistakes
+                    if (lowerValue === 'true' || lowerValue === '1' || lowerValue === 'yes' || lowerValue === 'on' || lowerValue === 'success')
+                        return true;
+                    if (lowerValue === 'false' || lowerValue === '0' || lowerValue === 'no' || lowerValue === 'off' || lowerValue === 'fail' || lowerValue === 'failed')
+                        return false;
+                    // If it's any non-empty string, treat as true (common LLM behavior)
+                    return lowerValue.length > 0;
+                }
+                if (typeof value === 'number') {
+                    return value !== 0;
+                }
+                return Boolean(value);
+            case 'object':
+                // Handle JSON string to object conversion
+                if (typeof value === 'string') {
+                    try {
+                        // Try to parse as JSON
+                        const parsed = JSON.parse(value);
+                        if (typeof parsed === 'object' && parsed !== null) {
+                            return parsed;
+                        }
+                    }
+                    catch (error) {
+                        // Not valid JSON, try other conversions
+                    }
+                    // Try to parse as query string (key=value&key2=value2)
+                    if (value.includes('=')) {
+                        try {
+                            const params = new URLSearchParams(value);
+                            const obj = {};
+                            params.forEach((val, key) => {
+                                obj[key] = val;
+                            });
+                            if (Object.keys(obj).length > 0) {
+                                return obj;
+                            }
+                        }
+                        catch (error) {
+                        }
+                    }
+                }
+                // If already an object, return as is
+                if (typeof value === 'object' && value !== null) {
+                    return value;
+                }
+                // Last resort: wrap primitive in object
+                return { value };
+            default:
+                return value;
+        }
+    }
+    /**
+     * Calculate retry delay with exponential backoff
+     */
+    calculateRetryDelay(attemptNumber) {
+        const delay = Math.min(this.config.retryDelayBase * Math.pow(this.config.retryDelayMultiplier, attemptNumber), this.config.maxRetryDelay);
+        // Add jitter to prevent thundering herd
+        const jitter = Math.random() * 0.1 * delay;
+        return Math.floor(delay + jitter);
+    }
+    /**
+     * Record a correction attempt
+     */
+    recordCorrectionAttempt(correctionKey, attempt) {
+        const attempts = this.correctionAttempts.get(correctionKey) || [];
+        attempts.push(attempt);
+        this.correctionAttempts.set(correctionKey, attempts);
+        // Clean up old attempts (keep last 10)
+        if (attempts.length > 10) {
+            attempts.splice(0, attempts.length - 10);
+        }
+    }
+    /**
+     * Learn from successful corrections
+     */
+    async learnFromSuccessfulCorrection(attempt) {
+        try {
+            // Store the successful correction as a pattern
+            await this.patternService.storeSuccessfulPattern(attempt.agentId, attempt.channelId, attempt.toolName, attempt.correctedParameters, attempt.recoveryTime);
+        }
+        catch (error) {
+            this.logger.warn(`Failed to learn from successful correction: ${error}`);
+        }
+    }
+    /**
+     * Audit correction attempt
+     * Logs correction attempts for analytics and debugging
+     */
+    async auditCorrectionAttempt(attempt) {
+        // Log correction attempt for analytics
+        this.logger.info(`Correction attempt: tool=${attempt.toolName}, ` +
+            `strategy=${attempt.strategy}, success=${attempt.successful}, ` +
+            `confidence=${attempt.confidence.toFixed(2)}`);
+        // Emit event for external systems to capture (can be persisted by listeners)
+        EventBus.server.emit('correction:attempt', {
+            toolName: attempt.toolName,
+            strategy: attempt.strategy,
+            successful: attempt.successful,
+            confidence: attempt.confidence,
+            timestamp: Date.now()
+        });
+    }
+    /**
+     * Setup event listeners
+     */
+    setupEventListeners() {
+        // Listen for tool execution errors
+        EventBus.server.on(Events.Mcp.TOOL_ERROR, async (payload) => {
+            if (!this.config.enabled)
+                return;
+            const { agentId, channelId, toolName, error, parameters } = payload;
+            // Auto-correction will be triggered by the ToolExecutionInterceptor
+            // This listener is for monitoring and analytics
+        });
+    }
+    /**
+     * Get default configuration
+     */
+    getDefaultConfig() {
+        return {
+            enabled: true,
+            maxRetryAttempts: 3,
+            confidenceThreshold: 0.7,
+            retryDelayBase: 1000, // 1 second
+            retryDelayMultiplier: 2,
+            maxRetryDelay: 30000, // 30 seconds
+            enabledStrategies: [
+                'missing_required',
+                'wrong_parameter_names',
+                'type_mismatch',
+                'pattern_based',
+                'json_string_conversion'
+            ],
+            learnFromSuccessfulCorrections: true,
+            auditAllAttempts: true
+        };
+    }
+    // =============================================================================
+    // PUBLIC API
+    // =============================================================================
+    /**
+     * Get correction events observable
+     */
+    get correctionEvents() {
+        return this.correctionEvents$.asObservable();
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Get correction statistics
+     */
+    getCorrectionStats() {
+        let totalAttempts = 0;
+        let successfulCorrections = 0;
+        const strategiesUsed = {};
+        for (const attempts of this.correctionAttempts.values()) {
+            for (const attempt of attempts) {
+                totalAttempts++;
+                if (attempt.successful)
+                    successfulCorrections++;
+                strategiesUsed[attempt.strategy] = (strategiesUsed[attempt.strategy] || 0) + 1;
+            }
+        }
+        const successRate = totalAttempts > 0 ? successfulCorrections / totalAttempts : 0;
+        const mostSuccessfulStrategy = Object.entries(strategiesUsed)
+            .sort(([, a], [, b]) => b - a)[0]?.[0] || null;
+        return {
+            totalAttempts,
+            successfulCorrections,
+            successRate,
+            strategiesUsed: strategiesUsed,
+            mostSuccessfulStrategy
+        };
+    }
+    /**
+     * Clear all correction history (for testing/cleanup)
+     */
+    clearCorrectionHistory() {
+        this.correctionAttempts.clear();
+        this.retryTimers.forEach(timer => clearTimeout(timer));
+        this.retryTimers.clear();
+    }
+}
+//# sourceMappingURL=AutoCorrectionService.js.map