@thinkhive/sdk 3.1.0 → 3.3.0

package/dist/api/quality-metrics.d.ts

@@ -0,0 +1,303 @@
+/**
+ * ThinkHive SDK v3.1 - Quality Metrics API
+ *
+ * RAG Evaluation & Hallucination Detection for AI quality assurance
+ */
+/**
+ * Retrieved context for RAG evaluation
+ */
+export interface RetrievedContext {
+    content: string;
+    chunkIndex?: number;
+    metadata?: Record<string, unknown>;
+    score?: number;
+}
+/**
+ * Ground truth context
+ */
+export interface GroundTruthContext {
+    content: string;
+    chunkIndex?: number;
+}
+/**
+ * Grounded span evidence
+ */
+export interface GroundedSpan {
+    text: string;
+    confidence: number;
+    sourceChunkIndex?: number;
+}
+/**
+ * Ungrounded span evidence
+ */
+export interface UngroundedSpan {
+    text: string;
+    confidence: number;
+}
+/**
+ * Citation mapping
+ */
+export interface CitationMap {
+    claim: string;
+    citedIndex: number;
+    isValid: boolean;
+}
+/**
+ * RAG evaluation result
+ */
+export interface RAGEvaluation {
+    contextRelevance: number;
+    contextPrecision: number;
+    contextRecall: number;
+    groundedness: number;
+    faithfulness: number;
+    answerRelevance: number;
+    citationAccuracy: number;
+    citationCompleteness: number;
+    overallScore: number;
+    grade: 'A' | 'B' | 'C' | 'D' | 'F';
+    groundedSpanCount?: number;
+    ungroundedSpanCount?: number;
+    issues: string[];
+    recommendations: string[];
+}
+/**
+ * RAG evaluation evidence
+ */
+export interface RAGEvidence {
+    groundedSpans: GroundedSpan[];
+    ungroundedSpans: UngroundedSpan[];
+    citationMap: CitationMap[];
+}
+/**
+ * Hallucination instance
+ */
+export interface HallucinationInstance {
+    type: string;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    text: string;
+    explanation: string;
+    confidence: number;
+    suggestedFix?: string;
+}
+/**
+ * Hallucination detection report
+ */
+export interface HallucinationReport {
+    hasHallucinations: boolean;
+    hallucinationScore: number;
+    riskLevel: 'low' | 'medium' | 'high' | 'critical';
+    factualClaims: number;
+    verifiedClaims: number;
+    unverifiedClaims: number;
+    summary: string;
+    recommendations: string[];
+    instances: HallucinationInstance[];
+}
+/**
+ * Groundedness analysis result
+ */
+export interface GroundednessResult {
+    score: number;
+    faithfulness: number;
+    contextRelevance: number;
+    grade: string;
+}
+/**
+ * Batch evaluation result for a single trace
+ */
+export interface BatchEvaluationResult {
+    traceId: string;
+    success: boolean;
+    error?: string;
+    rag?: {
+        score: number;
+        grade: string;
+        mainIssue?: string;
+    };
+    hallucination?: {
+        hasIssues: boolean;
+        score: number;
+        topIssue?: string;
+    };
+}
+/**
+ * Batch evaluation summary
+ */
+export interface BatchEvaluationSummary {
+    totalTraces: number;
+    successfulEvaluations: number;
+    avgRagScore: number;
+    hallucinationRate: number;
+    gradeDistribution: {
+        A: number;
+        B: number;
+        C: number;
+        D: number;
+        F: number;
+    };
+}
+/**
+ * Quality Metrics API client for RAG evaluation and hallucination detection
+ */
+export declare const qualityMetrics: {
+    /**
+     * Get RAG quality scores for a specific trace
+     *
+     * @example
+     * ```typescript
+     * const scores = await qualityMetrics.getRagScores('trace_abc123');
+     * console.log(`Groundedness: ${scores.evaluation.groundedness}`);
+     * console.log(`Grade: ${scores.evaluation.grade}`);
+     * ```
+     */
+    getRagScores(traceId: string): Promise<{
+        traceId: string;
+        evaluation: RAGEvaluation;
+        evidence: RAGEvidence;
+    }>;
+    /**
+     * Get hallucination detection report for a trace
+     *
+     * @example
+     * ```typescript
+     * const report = await qualityMetrics.getHallucinationReport('trace_abc123');
+     * if (report.report.hasHallucinations) {
+     *   console.log(`Risk level: ${report.report.riskLevel}`);
+     *   for (const instance of report.report.instances) {
+     *     console.log(`- ${instance.type}: ${instance.text}`);
+     *   }
+     * }
+     * ```
+     */
+    getHallucinationReport(traceId: string): Promise<{
+        traceId: string;
+        report: HallucinationReport;
+    }>;
+    /**
+     * Evaluate RAG quality for provided content (ad-hoc evaluation)
+     *
+     * @example
+     * ```typescript
+     * const result = await qualityMetrics.evaluateRag({
+     *   query: 'What is the refund policy?',
+     *   response: 'You can get a refund within 30 days.',
+     *   retrievedContexts: [
+     *     { content: 'Our refund policy allows returns within 30 days of purchase.' },
+     *   ],
+     * });
+     * console.log(`Groundedness: ${result.evaluation.groundedness}`);
+     * ```
+     */
+    evaluateRag(input: {
+        query: string;
+        response: string;
+        retrievedContexts: RetrievedContext[];
+        groundTruthContexts?: GroundTruthContext[];
+        citations?: string[];
+    }): Promise<{
+        evaluation: RAGEvaluation;
+        evidence: RAGEvidence;
+    }>;
+    /**
+     * Detect hallucinations in provided content (ad-hoc detection)
+     *
+     * @example
+     * ```typescript
+     * const result = await qualityMetrics.detectHallucinations({
+     *   response: 'The product costs $99 and comes with a 2-year warranty.',
+     *   contexts: [
+     *     { content: 'The product costs $99 with a 1-year warranty.' },
+     *   ],
+     * });
+     * if (result.report.hasHallucinations) {
+     *   console.log('Detected hallucinations:', result.report.instances);
+     * }
+     * ```
+     */
+    detectHallucinations(input: {
+        response: string;
+        contexts: Array<{
+            content: string;
+            metadata?: Record<string, unknown>;
+        }>;
+        query?: string;
+        previousResponses?: string[];
+    }): Promise<{
+        report: HallucinationReport;
+    }>;
+    /**
+     * Get groundedness analysis for a trace
+     *
+     * @example
+     * ```typescript
+     * const result = await qualityMetrics.getGroundedness('trace_abc123');
+     * console.log(`Groundedness score: ${result.groundedness.score}`);
+     * console.log(`Grounded spans: ${result.summary.groundedSpans}`);
+     * ```
+     */
+    getGroundedness(traceId: string): Promise<{
+        traceId: string;
+        groundedness: GroundednessResult;
+        spans: {
+            grounded: Array<{
+                text: string;
+                confidence: number;
+                sourceIndex: number;
+            }>;
+            ungrounded: Array<{
+                text: string;
+                confidence: number;
+            }>;
+        };
+        summary: {
+            totalSpans: number;
+            groundedSpans: number;
+            ungroundedSpans: number;
+            groundednessRatio: number;
+        };
+    }>;
+    /**
+     * Evaluate multiple traces for quality metrics in batch
+     *
+     * @example
+     * ```typescript
+     * const result = await qualityMetrics.evaluateBatch({
+     *   traceIds: ['trace_1', 'trace_2', 'trace_3'],
+     * });
+     * console.log(`Average RAG score: ${result.summary.avgRagScore}`);
+     * console.log(`Hallucination rate: ${result.summary.hallucinationRate}%`);
+     * ```
+     */
+    evaluateBatch(options: {
+        traceIds: string[];
+        includeDetails?: boolean;
+    }): Promise<{
+        summary: BatchEvaluationSummary;
+        results: BatchEvaluationResult[];
+    }>;
+};
+/**
+ * Check if a RAG evaluation passes quality thresholds
+ */
+export declare function passesQualityThreshold(evaluation: RAGEvaluation, thresholds?: {
+    minGroundedness?: number;
+    minOverallScore?: number;
+    minGrade?: 'A' | 'B' | 'C' | 'D';
+}): boolean;
+/**
+ * Check if hallucination risk is acceptable
+ */
+export declare function isHallucinationRiskAcceptable(report: HallucinationReport, maxRiskLevel?: 'low' | 'medium' | 'high'): boolean;
+/**
+ * Get quality recommendations based on evaluation
+ */
+export declare function getQualityRecommendations(ragEval: RAGEvaluation, hallucinationReport?: HallucinationReport): string[];
+/**
+ * Format quality score for display
+ */
+export declare function formatQualityScore(score: number): string;
+/**
+ * Get color indicator for grade
+ */
+export declare function getGradeColor(grade: 'A' | 'B' | 'C' | 'D' | 'F'): 'green' | 'blue' | 'yellow' | 'orange' | 'red';

package/dist/api/quality-metrics.js

@@ -0,0 +1,198 @@
+"use strict";
+/**
+ * ThinkHive SDK v3.1 - Quality Metrics API
+ *
+ * RAG Evaluation & Hallucination Detection for AI quality assurance
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.qualityMetrics = void 0;
+exports.passesQualityThreshold = passesQualityThreshold;
+exports.isHallucinationRiskAcceptable = isHallucinationRiskAcceptable;
+exports.getQualityRecommendations = getQualityRecommendations;
+exports.formatQualityScore = formatQualityScore;
+exports.getGradeColor = getGradeColor;
+const client_1 = require("../core/client");
+// ============================================================================
+// QUALITY METRICS API CLIENT
+// ============================================================================
+/**
+ * Quality Metrics API client for RAG evaluation and hallucination detection
+ */
+exports.qualityMetrics = {
+    /**
+     * Get RAG quality scores for a specific trace
+     *
+     * @example
+     * ```typescript
+     * const scores = await qualityMetrics.getRagScores('trace_abc123');
+     * console.log(`Groundedness: ${scores.evaluation.groundedness}`);
+     * console.log(`Grade: ${scores.evaluation.grade}`);
+     * ```
+     */
+    async getRagScores(traceId) {
+        return (0, client_1.apiRequestWithData)(`/quality/rag-scores/${traceId}`, {
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Get hallucination detection report for a trace
+     *
+     * @example
+     * ```typescript
+     * const report = await qualityMetrics.getHallucinationReport('trace_abc123');
+     * if (report.report.hasHallucinations) {
+     *   console.log(`Risk level: ${report.report.riskLevel}`);
+     *   for (const instance of report.report.instances) {
+     *     console.log(`- ${instance.type}: ${instance.text}`);
+     *   }
+     * }
+     * ```
+     */
+    async getHallucinationReport(traceId) {
+        return (0, client_1.apiRequestWithData)(`/quality/hallucination-report/${traceId}`, {
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Evaluate RAG quality for provided content (ad-hoc evaluation)
+     *
+     * @example
+     * ```typescript
+     * const result = await qualityMetrics.evaluateRag({
+     *   query: 'What is the refund policy?',
+     *   response: 'You can get a refund within 30 days.',
+     *   retrievedContexts: [
+     *     { content: 'Our refund policy allows returns within 30 days of purchase.' },
+     *   ],
+     * });
+     * console.log(`Groundedness: ${result.evaluation.groundedness}`);
+     * ```
+     */
+    async evaluateRag(input) {
+        return (0, client_1.apiRequestWithData)('/quality/evaluate-rag', {
+            method: 'POST',
+            body: input,
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Detect hallucinations in provided content (ad-hoc detection)
+     *
+     * @example
+     * ```typescript
+     * const result = await qualityMetrics.detectHallucinations({
+     *   response: 'The product costs $99 and comes with a 2-year warranty.',
+     *   contexts: [
+     *     { content: 'The product costs $99 with a 1-year warranty.' },
+     *   ],
+     * });
+     * if (result.report.hasHallucinations) {
+     *   console.log('Detected hallucinations:', result.report.instances);
+     * }
+     * ```
+     */
+    async detectHallucinations(input) {
+        return (0, client_1.apiRequestWithData)('/quality/detect-hallucinations', {
+            method: 'POST',
+            body: input,
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Get groundedness analysis for a trace
+     *
+     * @example
+     * ```typescript
+     * const result = await qualityMetrics.getGroundedness('trace_abc123');
+     * console.log(`Groundedness score: ${result.groundedness.score}`);
+     * console.log(`Grounded spans: ${result.summary.groundedSpans}`);
+     * ```
+     */
+    async getGroundedness(traceId) {
+        return (0, client_1.apiRequestWithData)(`/quality/groundedness/${traceId}`, {
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Evaluate multiple traces for quality metrics in batch
+     *
+     * @example
+     * ```typescript
+     * const result = await qualityMetrics.evaluateBatch({
+     *   traceIds: ['trace_1', 'trace_2', 'trace_3'],
+     * });
+     * console.log(`Average RAG score: ${result.summary.avgRagScore}`);
+     * console.log(`Hallucination rate: ${result.summary.hallucinationRate}%`);
+     * ```
+     */
+    async evaluateBatch(options) {
+        return (0, client_1.apiRequestWithData)('/quality/evaluate-batch', {
+            method: 'POST',
+            body: options,
+            apiVersion: 'v1',
+        });
+    },
+};
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Check if a RAG evaluation passes quality thresholds
+ */
+function passesQualityThreshold(evaluation, thresholds = {}) {
+    const { minGroundedness = 0.7, minOverallScore = 60, minGrade = 'C' } = thresholds;
+    const gradeOrder = { A: 4, B: 3, C: 2, D: 1, F: 0 };
+    const meetsGroundedness = evaluation.groundedness >= minGroundedness;
+    const meetsScore = evaluation.overallScore >= minOverallScore;
+    const meetsGrade = gradeOrder[evaluation.grade] >= gradeOrder[minGrade];
+    return meetsGroundedness && meetsScore && meetsGrade;
+}
+/**
+ * Check if hallucination risk is acceptable
+ */
+function isHallucinationRiskAcceptable(report, maxRiskLevel = 'medium') {
+    const riskOrder = { low: 0, medium: 1, high: 2, critical: 3 };
+    return riskOrder[report.riskLevel] <= riskOrder[maxRiskLevel];
+}
+/**
+ * Get quality recommendations based on evaluation
+ */
+function getQualityRecommendations(ragEval, hallucinationReport) {
+    const recommendations = [];
+    if (ragEval.groundedness < 0.7) {
+        recommendations.push('Improve grounding by increasing context relevance');
+    }
+    if (ragEval.contextRelevance < 0.6) {
+        recommendations.push('Tune retrieval to return more relevant contexts');
+    }
+    if (ragEval.citationAccuracy < 0.8) {
+        recommendations.push('Improve citation accuracy in responses');
+    }
+    if (hallucinationReport?.hasHallucinations) {
+        recommendations.push('Add fact-checking layer to reduce hallucinations');
+    }
+    if (recommendations.length === 0) {
+        recommendations.push('Quality metrics are within acceptable ranges');
+    }
+    return recommendations;
+}
+/**
+ * Format quality score for display
+ */
+function formatQualityScore(score) {
+    return `${Math.round(score * 100)}%`;
+}
+/**
+ * Get color indicator for grade
+ */
+function getGradeColor(grade) {
+    const colors = {
+        A: 'green',
+        B: 'blue',
+        C: 'yellow',
+        D: 'orange',
+        F: 'red',
+    };
+    return colors[grade];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quality-metrics.js","sourceRoot":"","sources":["../../src/api/quality-metrics.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK v3.1 - Quality Metrics API\n *\n * RAG Evaluation & Hallucination Detection for AI quality assurance\n */\n\nimport { apiRequest, apiRequestWithData } from '../core/client';\nimport type { ApiResponse } from '../core/types';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\n/**\n * Retrieved context for RAG evaluation\n */\nexport interface RetrievedContext {\n  content: string;\n  chunkIndex?: number;\n  metadata?: Record<string, unknown>;\n  score?: number;\n}\n\n/**\n * Ground truth context\n */\nexport interface GroundTruthContext {\n  content: string;\n  chunkIndex?: number;\n}\n\n/**\n * Grounded span evidence\n */\nexport interface GroundedSpan {\n  text: string;\n  confidence: number;\n  sourceChunkIndex?: number;\n}\n\n/**\n * Ungrounded span evidence\n */\nexport interface UngroundedSpan {\n  text: string;\n  confidence: number;\n}\n\n/**\n * Citation mapping\n */\nexport interface CitationMap {\n  claim: string;\n  citedIndex: number;\n  isValid: boolean;\n}\n\n/**\n * RAG evaluation result\n */\nexport interface RAGEvaluation {\n  // Retrieval Quality\n  contextRelevance: number;\n  contextPrecision: number;\n  contextRecall: number;\n\n  // Generation Quality\n  groundedness: number;\n  faithfulness: number;\n  answerRelevance: number;\n\n  // Citation Quality\n  citationAccuracy: number;\n  citationCompleteness: number;\n\n  // Overall\n  overallScore: number;\n  grade: 'A' | 'B' | 'C' | 'D' | 'F';\n\n  // Details\n  groundedSpanCount?: number;\n  ungroundedSpanCount?: number;\n  issues: string[];\n  recommendations: string[];\n}\n\n/**\n * RAG evaluation evidence\n */\nexport interface RAGEvidence {\n  groundedSpans: GroundedSpan[];\n  ungroundedSpans: UngroundedSpan[];\n  citationMap: CitationMap[];\n}\n\n/**\n * Hallucination instance\n */\nexport interface HallucinationInstance {\n  type: string;\n  severity: 'low' | 'medium' | 'high' | 'critical';\n  text: string;\n  explanation: string;\n  confidence: number;\n  suggestedFix?: string;\n}\n\n/**\n * Hallucination detection report\n */\nexport interface HallucinationReport {\n  hasHallucinations: boolean;\n  hallucinationScore: number;\n  riskLevel: 'low' | 'medium' | 'high' | 'critical';\n  factualClaims: number;\n  verifiedClaims: number;\n  unverifiedClaims: number;\n  summary: string;\n  recommendations: string[];\n  instances: HallucinationInstance[];\n}\n\n/**\n * Groundedness analysis result\n */\nexport interface GroundednessResult {\n  score: number;\n  faithfulness: number;\n  contextRelevance: number;\n  grade: string;\n}\n\n/**\n * Batch evaluation result for a single trace\n */\nexport interface BatchEvaluationResult {\n  traceId: string;\n  success: boolean;\n  error?: string;\n  rag?: {\n    score: number;\n    grade: string;\n    mainIssue?: string;\n  };\n  hallucination?: {\n    hasIssues: boolean;\n    score: number;\n    topIssue?: string;\n  };\n}\n\n/**\n * Batch evaluation summary\n */\nexport interface BatchEvaluationSummary {\n  totalTraces: number;\n  successfulEvaluations: number;\n  avgRagScore: number;\n  hallucinationRate: number;\n  gradeDistribution: {\n    A: number;\n    B: number;\n    C: number;\n    D: number;\n    F: number;\n  };\n}\n\n// ============================================================================\n// QUALITY METRICS API CLIENT\n// ============================================================================\n\n/**\n * Quality Metrics API client for RAG evaluation and hallucination detection\n */\nexport const qualityMetrics = {\n  /**\n   * Get RAG quality scores for a specific trace\n   *\n   * @example\n   * ```typescript\n   * const scores = await qualityMetrics.getRagScores('trace_abc123');\n   * console.log(`Groundedness: ${scores.evaluation.groundedness}`);\n   * console.log(`Grade: ${scores.evaluation.grade}`);\n   * ```\n   */\n  async getRagScores(traceId: string): Promise<{\n    traceId: string;\n    evaluation: RAGEvaluation;\n    evidence: RAGEvidence;\n  }> {\n    return apiRequestWithData(`/quality/rag-scores/${traceId}`, {\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Get hallucination detection report for a trace\n   *\n   * @example\n   * ```typescript\n   * const report = await qualityMetrics.getHallucinationReport('trace_abc123');\n   * if (report.report.hasHallucinations) {\n   *   console.log(`Risk level: ${report.report.riskLevel}`);\n   *   for (const instance of report.report.instances) {\n   *     console.log(`- ${instance.type}: ${instance.text}`);\n   *   }\n   * }\n   * ```\n   */\n  async getHallucinationReport(traceId: string): Promise<{\n    traceId: string;\n    report: HallucinationReport;\n  }> {\n    return apiRequestWithData(`/quality/hallucination-report/${traceId}`, {\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Evaluate RAG quality for provided content (ad-hoc evaluation)\n   *\n   * @example\n   * ```typescript\n   * const result = await qualityMetrics.evaluateRag({\n   *   query: 'What is the refund policy?',\n   *   response: 'You can get a refund within 30 days.',\n   *   retrievedContexts: [\n   *     { content: 'Our refund policy allows returns within 30 days of purchase.' },\n   *   ],\n   * });\n   * console.log(`Groundedness: ${result.evaluation.groundedness}`);\n   * ```\n   */\n  async evaluateRag(input: {\n    query: string;\n    response: string;\n    retrievedContexts: RetrievedContext[];\n    groundTruthContexts?: GroundTruthContext[];\n    citations?: string[];\n  }): Promise<{\n    evaluation: RAGEvaluation;\n    evidence: RAGEvidence;\n  }> {\n    return apiRequestWithData('/quality/evaluate-rag', {\n      method: 'POST',\n      body: input,\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Detect hallucinations in provided content (ad-hoc detection)\n   *\n   * @example\n   * ```typescript\n   * const result = await qualityMetrics.detectHallucinations({\n   *   response: 'The product costs $99 and comes with a 2-year warranty.',\n   *   contexts: [\n   *     { content: 'The product costs $99 with a 1-year warranty.' },\n   *   ],\n   * });\n   * if (result.report.hasHallucinations) {\n   *   console.log('Detected hallucinations:', result.report.instances);\n   * }\n   * ```\n   */\n  async detectHallucinations(input: {\n    response: string;\n    contexts: Array<{ content: string; metadata?: Record<string, unknown> }>;\n    query?: string;\n    previousResponses?: string[];\n  }): Promise<{\n    report: HallucinationReport;\n  }> {\n    return apiRequestWithData('/quality/detect-hallucinations', {\n      method: 'POST',\n      body: input,\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Get groundedness analysis for a trace\n   *\n   * @example\n   * ```typescript\n   * const result = await qualityMetrics.getGroundedness('trace_abc123');\n   * console.log(`Groundedness score: ${result.groundedness.score}`);\n   * console.log(`Grounded spans: ${result.summary.groundedSpans}`);\n   * ```\n   */\n  async getGroundedness(traceId: string): Promise<{\n    traceId: string;\n    groundedness: GroundednessResult;\n    spans: {\n      grounded: Array<{ text: string; confidence: number; sourceIndex: number }>;\n      ungrounded: Array<{ text: string; confidence: number }>;\n    };\n    summary: {\n      totalSpans: number;\n      groundedSpans: number;\n      ungroundedSpans: number;\n      groundednessRatio: number;\n    };\n  }> {\n    return apiRequestWithData(`/quality/groundedness/${traceId}`, {\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Evaluate multiple traces for quality metrics in batch\n   *\n   * @example\n   * ```typescript\n   * const result = await qualityMetrics.evaluateBatch({\n   *   traceIds: ['trace_1', 'trace_2', 'trace_3'],\n   * });\n   * console.log(`Average RAG score: ${result.summary.avgRagScore}`);\n   * console.log(`Hallucination rate: ${result.summary.hallucinationRate}%`);\n   * ```\n   */\n  async evaluateBatch(options: {\n    traceIds: string[];\n    includeDetails?: boolean;\n  }): Promise<{\n    summary: BatchEvaluationSummary;\n    results: BatchEvaluationResult[];\n  }> {\n    return apiRequestWithData('/quality/evaluate-batch', {\n      method: 'POST',\n      body: options,\n      apiVersion: 'v1',\n    });\n  },\n};\n\n// ============================================================================\n// HELPER FUNCTIONS\n// ============================================================================\n\n/**\n * Check if a RAG evaluation passes quality thresholds\n */\nexport function passesQualityThreshold(\n  evaluation: RAGEvaluation,\n  thresholds: {\n    minGroundedness?: number;\n    minOverallScore?: number;\n    minGrade?: 'A' | 'B' | 'C' | 'D';\n  } = {}\n): boolean {\n  const { minGroundedness = 0.7, minOverallScore = 60, minGrade = 'C' } = thresholds;\n\n  const gradeOrder = { A: 4, B: 3, C: 2, D: 1, F: 0 };\n  const meetsGroundedness = evaluation.groundedness >= minGroundedness;\n  const meetsScore = evaluation.overallScore >= minOverallScore;\n  const meetsGrade = gradeOrder[evaluation.grade] >= gradeOrder[minGrade];\n\n  return meetsGroundedness && meetsScore && meetsGrade;\n}\n\n/**\n * Check if hallucination risk is acceptable\n */\nexport function isHallucinationRiskAcceptable(\n  report: HallucinationReport,\n  maxRiskLevel: 'low' | 'medium' | 'high' = 'medium'\n): boolean {\n  const riskOrder = { low: 0, medium: 1, high: 2, critical: 3 };\n  return riskOrder[report.riskLevel] <= riskOrder[maxRiskLevel];\n}\n\n/**\n * Get quality recommendations based on evaluation\n */\nexport function getQualityRecommendations(\n  ragEval: RAGEvaluation,\n  hallucinationReport?: HallucinationReport\n): string[] {\n  const recommendations: string[] = [];\n\n  if (ragEval.groundedness < 0.7) {\n    recommendations.push('Improve grounding by increasing context relevance');\n  }\n\n  if (ragEval.contextRelevance < 0.6) {\n    recommendations.push('Tune retrieval to return more relevant contexts');\n  }\n\n  if (ragEval.citationAccuracy < 0.8) {\n    recommendations.push('Improve citation accuracy in responses');\n  }\n\n  if (hallucinationReport?.hasHallucinations) {\n    recommendations.push('Add fact-checking layer to reduce hallucinations');\n  }\n\n  if (recommendations.length === 0) {\n    recommendations.push('Quality metrics are within acceptable ranges');\n  }\n\n  return recommendations;\n}\n\n/**\n * Format quality score for display\n */\nexport function formatQualityScore(score: number): string {\n  return `${Math.round(score * 100)}%`;\n}\n\n/**\n * Get color indicator for grade\n */\nexport function getGradeColor(\n  grade: 'A' | 'B' | 'C' | 'D' | 'F'\n): 'green' | 'blue' | 'yellow' | 'orange' | 'red' {\n  const colors = {\n    A: 'green' as const,\n    B: 'blue' as const,\n    C: 'yellow' as const,\n    D: 'orange' as const,\n    F: 'red' as const,\n  };\n  return colors[grade];\n}\n"]}