@spaik/mcp-server-roi/dist/services/quality-assurance.d.ts

MCP server for AI ROI prediction and tracking with Monte Carlo simulations

import { z } from 'zod';
/**
 * Quality Assurance Service
 *
 * Ensures response quality, validates insights, and maintains
 * consistency across all AI-optimized outputs.
 */
export declare const QualityMetricsSchema: z.ZodObject<{
    accuracy: z.ZodNumber;
    completeness: z.ZodNumber;
    clarity: z.ZodNumber;
    relevance: z.ZodNumber;
    consistency: z.ZodNumber;
    overall_score: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    accuracy: number;
    completeness: number;
    clarity: number;
    relevance: number;
    consistency: number;
    overall_score: number;
}, {
    accuracy: number;
    completeness: number;
    clarity: number;
    relevance: number;
    consistency: number;
    overall_score: number;
}>;
export declare const QualityIssueSchema: z.ZodObject<{
    severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
    category: z.ZodEnum<["accuracy", "completeness", "clarity", "consistency", "logic"]>;
    description: z.ZodString;
    location: z.ZodOptional<z.ZodString>;
    suggested_fix: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    description: string;
    category: "accuracy" | "completeness" | "clarity" | "consistency" | "logic";
    severity: "low" | "medium" | "high" | "critical";
    location?: string | undefined;
    suggested_fix?: string | undefined;
}, {
    description: string;
    category: "accuracy" | "completeness" | "clarity" | "consistency" | "logic";
    severity: "low" | "medium" | "high" | "critical";
    location?: string | undefined;
    suggested_fix?: string | undefined;
}>;
export declare const QualityReportSchema: z.ZodObject<{
    metrics: z.ZodObject<{
        accuracy: z.ZodNumber;
        completeness: z.ZodNumber;
        clarity: z.ZodNumber;
        relevance: z.ZodNumber;
        consistency: z.ZodNumber;
        overall_score: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        accuracy: number;
        completeness: number;
        clarity: number;
        relevance: number;
        consistency: number;
        overall_score: number;
    }, {
        accuracy: number;
        completeness: number;
        clarity: number;
        relevance: number;
        consistency: number;
        overall_score: number;
    }>;
    issues: z.ZodArray<z.ZodObject<{
        severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
        category: z.ZodEnum<["accuracy", "completeness", "clarity", "consistency", "logic"]>;
        description: z.ZodString;
        location: z.ZodOptional<z.ZodString>;
        suggested_fix: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        description: string;
        category: "accuracy" | "completeness" | "clarity" | "consistency" | "logic";
        severity: "low" | "medium" | "high" | "critical";
        location?: string | undefined;
        suggested_fix?: string | undefined;
    }, {
        description: string;
        category: "accuracy" | "completeness" | "clarity" | "consistency" | "logic";
        severity: "low" | "medium" | "high" | "critical";
        location?: string | undefined;
        suggested_fix?: string | undefined;
    }>, "many">;
    passed: z.ZodBoolean;
    confidence: z.ZodNumber;
    recommendations: z.ZodArray<z.ZodString, "many">;
    validation_rules_applied: z.ZodNumber;
    auto_corrections: z.ZodArray<z.ZodObject<{
        issue: z.ZodString;
        correction: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        issue: string;
        correction: string;
    }, {
        issue: string;
        correction: string;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    issues: {
        description: string;
        category: "accuracy" | "completeness" | "clarity" | "consistency" | "logic";
        severity: "low" | "medium" | "high" | "critical";
        location?: string | undefined;
        suggested_fix?: string | undefined;
    }[];
    confidence: number;
    recommendations: string[];
    metrics: {
        accuracy: number;
        completeness: number;
        clarity: number;
        relevance: number;
        consistency: number;
        overall_score: number;
    };
    passed: boolean;
    validation_rules_applied: number;
    auto_corrections: {
        issue: string;
        correction: string;
    }[];
}, {
    issues: {
        description: string;
        category: "accuracy" | "completeness" | "clarity" | "consistency" | "logic";
        severity: "low" | "medium" | "high" | "critical";
        location?: string | undefined;
        suggested_fix?: string | undefined;
    }[];
    confidence: number;
    recommendations: string[];
    metrics: {
        accuracy: number;
        completeness: number;
        clarity: number;
        relevance: number;
        consistency: number;
        overall_score: number;
    };
    passed: boolean;
    validation_rules_applied: number;
    auto_corrections: {
        issue: string;
        correction: string;
    }[];
}>;
export type QualityMetrics = z.infer<typeof QualityMetricsSchema>;
export type QualityIssue = z.infer<typeof QualityIssueSchema>;
export type QualityReport = z.infer<typeof QualityReportSchema>;
export declare class QualityAssurance {
    private logger;
    private readonly QUALITY_THRESHOLDS;
    private readonly VALIDATION_RULES;
    /**
     * Validate response quality
     */
    validateResponse(response: any, context?: {
        tool: string;
        input: any;
        expectations?: any;
    }): Promise<QualityReport>;
    /**
     * Ensure consistency across responses
     */
    ensureConsistency(responses: any[], crossCheckType: 'temporal' | 'logical' | 'semantic'): Promise<{
        consistent: boolean;
        inconsistencies: Array<{
            type: string;
            description: string;
            affected_responses: number[];
            severity: 'high' | 'medium' | 'low';
        }>;
        alignment_score: number;
    }>;
    /**
     * Validate insights quality
     */
    validateInsights(insights: any, sourceData: any): Promise<{
        valid: boolean;
        issues: string[];
        insight_quality_scores: Record<string, number>;
        evidence_strength: number;
    }>;
    /**
     * Perform semantic validation
     */
    validateSemantics(response: any): Promise<{
        coherent: boolean;
        semantic_issues: Array<{
            type: 'contradiction' | 'ambiguity' | 'redundancy' | 'gap';
            description: string;
            severity: number;
        }>;
        readability_score: number;
    }>;
    /**
     * Auto-improve response quality
     */
    autoImproveResponse(response: any, qualityReport: QualityReport): Promise<{
        improved_response: any;
        improvements_made: string[];
        quality_delta: number;
    }>;
    private validateStructure;
    private validateDataIntegrity;
    private validateBusinessLogic;
    private validateConsistency;
    private calculateQualityMetrics;
    private collectIssues;
    private applyAutoCorrections;
    private generateQualityRecommendations;
    private determineQualityPass;
    private calculateConfidence;
    private countAppliedRules;
    private checkTemporalConsistency;
    private checkLogicalConsistency;
    private checkSemanticConsistency;
    private calculateAlignmentScore;
    private scoreInsightQuality;
    private scoreRiskValidity;
    private scoreOpportunityFeasibility;
    private calculateEvidenceStrength;
    private findContradictions;
    private findAmbiguities;
    private findRedundancies;
    private findSemanticGaps;
    private calculateReadability;
    private fixIssue;
    private enhanceClarity;
    private enhanceCompleteness;
    private getSuggestedFix;
    private extractKeyTerms;
    private hasDataSupport;
}
export declare const qualityAssurance: QualityAssurance;
//# sourceMappingURL=quality-assurance.d.ts.map