@thinkhive/sdk 3.1.1 → 4.0.0

package/dist/api/nondeterminism.js

@@ -0,0 +1,250 @@
+"use strict";
+/**
+ * ThinkHive SDK v3.0 - Non-Determinism API
+ *
+ * API for pass@k / pass^k analysis to measure LLM evaluation reliability
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nondeterminism = void 0;
+exports.calculatePassAtK = calculatePassAtK;
+exports.calculatePassToK = calculatePassToK;
+exports.requiredPassRateForPassAtK = requiredPassRateForPassAtK;
+exports.isReliableEvaluation = isReliableEvaluation;
+exports.getReliabilityRecommendation = getReliabilityRecommendation;
+const client_1 = require("../core/client");
+// ============================================================================
+// NON-DETERMINISM API CLIENT
+// ============================================================================
+/**
+ * Non-Determinism API client for pass@k analysis and reliability measurement
+ */
+exports.nondeterminism = {
+    /**
+     * Create a new non-determinism analysis run
+     *
+     * @example
+     * ```typescript
+     * const run = await nondeterminism.createRun({
+     *   agentId: 'agent_123',
+     *   criterionId: 'criterion_456',
+     *   kValue: 5,
+     *   traceIds: ['trace_1', 'trace_2', 'trace_3'],
+     *   runType: 'pass_at_k',
+     * });
+     * ```
+     */
+    async createRun(options) {
+        return (0, client_1.apiRequestWithData)('/nondeterminism/runs', {
+            method: 'POST',
+            body: options,
+            apiVersion: 'none',
+        });
+    },
+    /**
+     * Get non-determinism runs
+     *
+     * @example
+     * ```typescript
+     * const runs = await nondeterminism.getRuns({ agentId: 'agent_123' });
+     * ```
+     */
+    async getRuns(options = {}) {
+        const params = new URLSearchParams();
+        if (options.agentId)
+            params.set('agentId', options.agentId);
+        if (options.status)
+            params.set('status', options.status);
+        if (options.limit)
+            params.set('limit', String(options.limit));
+        if (options.offset)
+            params.set('offset', String(options.offset));
+        return (0, client_1.apiRequestWithData)(`/nondeterminism/runs?${params.toString()}`, { apiVersion: 'none' });
+    },
+    /**
+     * Get a specific run
+     *
+     * @example
+     * ```typescript
+     * const run = await nondeterminism.getRun('run_123');
+     * ```
+     */
+    async getRun(runId) {
+        return (0, client_1.apiRequestWithData)(`/nondeterminism/runs/${runId}`, { apiVersion: 'none' });
+    },
+    /**
+     * Start a run
+     *
+     * @example
+     * ```typescript
+     * await nondeterminism.startRun('run_123');
+     * ```
+     */
+    async startRun(runId) {
+        await (0, client_1.apiRequest)(`/nondeterminism/runs/${runId}/start`, {
+            method: 'POST',
+            apiVersion: 'none',
+        });
+    },
+    /**
+     * Complete a run
+     *
+     * @example
+     * ```typescript
+     * await nondeterminism.completeRun('run_123');
+     * ```
+     */
+    async completeRun(runId) {
+        await (0, client_1.apiRequest)(`/nondeterminism/runs/${runId}/complete`, {
+            method: 'POST',
+            apiVersion: 'none',
+        });
+    },
+    /**
+     * Record a sample result
+     *
+     * @example
+     * ```typescript
+     * const sample = await nondeterminism.recordSample({
+     *   runId: 'run_123',
+     *   traceId: 'trace_456',
+     *   criterionId: 'criterion_789',
+     *   sampleIndex: 0,
+     *   score: 85,
+     *   passed: true,
+     *   reasoning: 'Response meets quality criteria',
+     * });
+     * ```
+     */
+    async recordSample(options) {
+        return (0, client_1.apiRequestWithData)('/nondeterminism/samples', {
+            method: 'POST',
+            body: options,
+            apiVersion: 'none',
+        });
+    },
+    /**
+     * Get samples for a run
+     *
+     * @example
+     * ```typescript
+     * const samples = await nondeterminism.getSamples('run_123');
+     * ```
+     */
+    async getSamples(runId) {
+        return (0, client_1.apiRequestWithData)(`/nondeterminism/runs/${runId}/samples`, { apiVersion: 'none' });
+    },
+    /**
+     * Get run summary with analysis
+     *
+     * @example
+     * ```typescript
+     * const summary = await nondeterminism.getRunSummary('run_123');
+     * console.log(`Pass@k rate: ${summary.criterionAnalyses[0].passAtKRate}`);
+     * ```
+     */
+    async getRunSummary(runId) {
+        return (0, client_1.apiRequestWithData)(`/nondeterminism/runs/${runId}/summary`, { apiVersion: 'none' });
+    },
+    /**
+     * Trigger analysis of a completed run
+     *
+     * @example
+     * ```typescript
+     * const summary = await nondeterminism.analyzeRun('run_123');
+     * ```
+     */
+    async analyzeRun(runId) {
+        return (0, client_1.apiRequestWithData)(`/nondeterminism/runs/${runId}/analyze`, { method: 'POST', apiVersion: 'none' });
+    },
+    /**
+     * Get information about pass@k analysis
+     *
+     * @example
+     * ```typescript
+     * const info = await nondeterminism.getInfo();
+     * console.log(info.concepts.passAtK.description);
+     * ```
+     */
+    async getInfo() {
+        return (0, client_1.apiRequestWithData)('/nondeterminism/info', { apiVersion: 'none' });
+    },
+};
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Calculate pass@k probability from pass rate
+ *
+ * @param passRate - Single-run pass rate (0-1)
+ * @param k - Number of runs
+ * @returns Probability that at least 1 of k runs passes
+ *
+ * @example
+ * ```typescript
+ * const passAtK = calculatePassAtK(0.7, 3); // ~0.973
+ * ```
+ */
+function calculatePassAtK(passRate, k) {
+    return 1 - Math.pow(1 - passRate, k);
+}
+/**
+ * Calculate pass^k probability from pass rate
+ *
+ * @param passRate - Single-run pass rate (0-1)
+ * @param k - Number of runs
+ * @returns Probability that all k runs pass
+ *
+ * @example
+ * ```typescript
+ * const passToK = calculatePassToK(0.7, 3); // ~0.343
+ * ```
+ */
+function calculatePassToK(passRate, k) {
+    return Math.pow(passRate, k);
+}
+/**
+ * Calculate required pass rate to achieve target pass@k
+ *
+ * @param targetPassAtK - Desired pass@k probability
+ * @param k - Number of runs
+ * @returns Required single-run pass rate
+ *
+ * @example
+ * ```typescript
+ * const requiredRate = requiredPassRateForPassAtK(0.95, 3); // ~0.632
+ * ```
+ */
+function requiredPassRateForPassAtK(targetPassAtK, k) {
+    return 1 - Math.pow(1 - targetPassAtK, 1 / k);
+}
+/**
+ * Determine if evaluation is reliable based on analysis
+ *
+ * @param analysis - Criterion analysis result
+ * @param reliabilityThreshold - Minimum reliability score (default 0.8)
+ * @returns Whether the evaluation is considered reliable
+ */
+function isReliableEvaluation(analysis, reliabilityThreshold = 0.8) {
+    return analysis.reliabilityScore >= reliabilityThreshold;
+}
+/**
+ * Get recommendation based on reliability analysis
+ *
+ * @param analysis - Criterion analysis result
+ * @returns Actionable recommendation string
+ */
+function getReliabilityRecommendation(analysis) {
+    if (analysis.reliabilityScore >= 0.9) {
+        return 'Evaluation is highly reliable. No changes needed.';
+    }
+    else if (analysis.reliabilityScore >= 0.8) {
+        return 'Evaluation is reliable. Consider minor criteria refinements.';
+    }
+    else if (analysis.reliabilityScore >= 0.6) {
+        return 'Evaluation has moderate reliability. Add more specific criteria or examples.';
+    }
+    else {
+        return 'Evaluation is unreliable. Consider using deterministic checks or restructuring criteria.';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nondeterminism.js","sourceRoot":"","sources":["../../src/api/nondeterminism.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK v3.0 - Non-Determinism API\n *\n * API for pass@k / pass^k analysis to measure LLM evaluation reliability\n */\n\nimport { apiRequest, apiRequestWithData } from '../core/client';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\nexport type NondeterminismRunType = 'pass_at_k' | 'pass_to_k' | 'variance' | 'reliability';\nexport type NondeterminismRunStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';\n\nexport interface NondeterminismRun {\n  id: string;\n  companyId: string;\n  agentId: string;\n  runType: NondeterminismRunType;\n  kValue: number;\n  status: NondeterminismRunStatus;\n  traceCount: number;\n  criterionId?: string;\n  criteriaIds: string[];\n  temperature?: string;\n  model?: string;\n  progressPercent: number;\n  passAtKRate?: string;\n  passToKRate?: string;\n  avgVariance?: string;\n  reliabilityScore?: string;\n  startedAt?: string;\n  completedAt?: string;\n  createdBy?: string;\n  createdAt: string;\n}\n\nexport interface NondeterminismSample {\n  id: string;\n  runId: string;\n  traceId: string;\n  criterionId: string;\n  sampleIndex: number;\n  score: string;\n  passed: boolean;\n  reasoning?: string;\n  confidence?: string;\n  tokensUsed?: number;\n  costUsd?: string;\n  model?: string;\n  temperature?: string;\n  latencyMs?: number;\n  error?: string;\n  createdAt: string;\n}\n\nexport interface CreateRunOptions {\n  agentId: string;\n  criterionId?: string;\n  criteriaIds?: string[];\n  kValue: number;\n  traceIds: string[];\n  runType?: NondeterminismRunType;\n  temperature?: number;\n  model?: string;\n}\n\nexport interface RecordSampleOptions {\n  runId: string;\n  traceId: string;\n  criterionId: string;\n  sampleIndex: number;\n  score: number;\n  passed: boolean;\n  reasoning?: string;\n  confidence?: number;\n  tokensUsed?: number;\n  costUsd?: number;\n  model?: string;\n  temperature?: number;\n  latencyMs?: number;\n  error?: string;\n}\n\nexport interface TraceAnalysis {\n  traceId: string;\n  samples: NondeterminismSample[];\n  passCount: number;\n  totalCount: number;\n  passRate: number;\n  scoreVariance: number;\n  meanScore: number;\n  isConsistent: boolean;\n}\n\nexport interface CriterionAnalysis {\n  criterionId: string;\n  traceAnalyses: TraceAnalysis[];\n  passAtKRate: number;\n  passToKRate: number;\n  reliabilityScore: number;\n  isReliable: boolean;\n  recommendation: string;\n}\n\nexport interface RunSummary {\n  run: NondeterminismRun;\n  traceAnalyses: TraceAnalysis[];\n  criterionAnalyses: CriterionAnalysis[];\n}\n\nexport interface ListRunsOptions {\n  agentId?: string;\n  status?: NondeterminismRunStatus;\n  limit?: number;\n  offset?: number;\n}\n\nexport interface PassAtKInfo {\n  concepts: {\n    passAtK: { name: string; description: string; formula: string; useCase: string };\n    passToK: { name: string; description: string; formula: string; useCase: string };\n    variance: { name: string; description: string; useCase: string };\n    reliability: { name: string; description: string; useCase: string };\n  };\n  recommendations: Record<string, string>;\n  defaults: { kValue: number; reliabilityThreshold: number; varianceThreshold: number };\n}\n\n// ============================================================================\n// NON-DETERMINISM API CLIENT\n// ============================================================================\n\n/**\n * Non-Determinism API client for pass@k analysis and reliability measurement\n */\nexport const nondeterminism = {\n  /**\n   * Create a new non-determinism analysis run\n   *\n   * @example\n   * ```typescript\n   * const run = await nondeterminism.createRun({\n   *   agentId: 'agent_123',\n   *   criterionId: 'criterion_456',\n   *   kValue: 5,\n   *   traceIds: ['trace_1', 'trace_2', 'trace_3'],\n   *   runType: 'pass_at_k',\n   * });\n   * ```\n   */\n  async createRun(options: CreateRunOptions): Promise<NondeterminismRun> {\n    return apiRequestWithData<NondeterminismRun>('/nondeterminism/runs', {\n      method: 'POST',\n      body: options,\n      apiVersion: 'none',\n    });\n  },\n\n  /**\n   * Get non-determinism runs\n   *\n   * @example\n   * ```typescript\n   * const runs = await nondeterminism.getRuns({ agentId: 'agent_123' });\n   * ```\n   */\n  async getRuns(options: ListRunsOptions = {}): Promise<NondeterminismRun[]> {\n    const params = new URLSearchParams();\n    if (options.agentId) params.set('agentId', options.agentId);\n    if (options.status) params.set('status', options.status);\n    if (options.limit) params.set('limit', String(options.limit));\n    if (options.offset) params.set('offset', String(options.offset));\n\n    return apiRequestWithData<NondeterminismRun[]>(\n      `/nondeterminism/runs?${params.toString()}`,\n      { apiVersion: 'none' }\n    );\n  },\n\n  /**\n   * Get a specific run\n   *\n   * @example\n   * ```typescript\n   * const run = await nondeterminism.getRun('run_123');\n   * ```\n   */\n  async getRun(runId: string): Promise<NondeterminismRun> {\n    return apiRequestWithData<NondeterminismRun>(\n      `/nondeterminism/runs/${runId}`,\n      { apiVersion: 'none' }\n    );\n  },\n\n  /**\n   * Start a run\n   *\n   * @example\n   * ```typescript\n   * await nondeterminism.startRun('run_123');\n   * ```\n   */\n  async startRun(runId: string): Promise<void> {\n    await apiRequest(`/nondeterminism/runs/${runId}/start`, {\n      method: 'POST',\n      apiVersion: 'none',\n    });\n  },\n\n  /**\n   * Complete a run\n   *\n   * @example\n   * ```typescript\n   * await nondeterminism.completeRun('run_123');\n   * ```\n   */\n  async completeRun(runId: string): Promise<void> {\n    await apiRequest(`/nondeterminism/runs/${runId}/complete`, {\n      method: 'POST',\n      apiVersion: 'none',\n    });\n  },\n\n  /**\n   * Record a sample result\n   *\n   * @example\n   * ```typescript\n   * const sample = await nondeterminism.recordSample({\n   *   runId: 'run_123',\n   *   traceId: 'trace_456',\n   *   criterionId: 'criterion_789',\n   *   sampleIndex: 0,\n   *   score: 85,\n   *   passed: true,\n   *   reasoning: 'Response meets quality criteria',\n   * });\n   * ```\n   */\n  async recordSample(options: RecordSampleOptions): Promise<NondeterminismSample> {\n    return apiRequestWithData<NondeterminismSample>('/nondeterminism/samples', {\n      method: 'POST',\n      body: options,\n      apiVersion: 'none',\n    });\n  },\n\n  /**\n   * Get samples for a run\n   *\n   * @example\n   * ```typescript\n   * const samples = await nondeterminism.getSamples('run_123');\n   * ```\n   */\n  async getSamples(runId: string): Promise<NondeterminismSample[]> {\n    return apiRequestWithData<NondeterminismSample[]>(\n      `/nondeterminism/runs/${runId}/samples`,\n      { apiVersion: 'none' }\n    );\n  },\n\n  /**\n   * Get run summary with analysis\n   *\n   * @example\n   * ```typescript\n   * const summary = await nondeterminism.getRunSummary('run_123');\n   * console.log(`Pass@k rate: ${summary.criterionAnalyses[0].passAtKRate}`);\n   * ```\n   */\n  async getRunSummary(runId: string): Promise<RunSummary> {\n    return apiRequestWithData<RunSummary>(\n      `/nondeterminism/runs/${runId}/summary`,\n      { apiVersion: 'none' }\n    );\n  },\n\n  /**\n   * Trigger analysis of a completed run\n   *\n   * @example\n   * ```typescript\n   * const summary = await nondeterminism.analyzeRun('run_123');\n   * ```\n   */\n  async analyzeRun(runId: string): Promise<RunSummary> {\n    return apiRequestWithData<RunSummary>(\n      `/nondeterminism/runs/${runId}/analyze`,\n      { method: 'POST', apiVersion: 'none' }\n    );\n  },\n\n  /**\n   * Get information about pass@k analysis\n   *\n   * @example\n   * ```typescript\n   * const info = await nondeterminism.getInfo();\n   * console.log(info.concepts.passAtK.description);\n   * ```\n   */\n  async getInfo(): Promise<PassAtKInfo> {\n    return apiRequestWithData<PassAtKInfo>(\n      '/nondeterminism/info',\n      { apiVersion: 'none' }\n    );\n  },\n};\n\n// ============================================================================\n// HELPER FUNCTIONS\n// ============================================================================\n\n/**\n * Calculate pass@k probability from pass rate\n *\n * @param passRate - Single-run pass rate (0-1)\n * @param k - Number of runs\n * @returns Probability that at least 1 of k runs passes\n *\n * @example\n * ```typescript\n * const passAtK = calculatePassAtK(0.7, 3); // ~0.973\n * ```\n */\nexport function calculatePassAtK(passRate: number, k: number): number {\n  return 1 - Math.pow(1 - passRate, k);\n}\n\n/**\n * Calculate pass^k probability from pass rate\n *\n * @param passRate - Single-run pass rate (0-1)\n * @param k - Number of runs\n * @returns Probability that all k runs pass\n *\n * @example\n * ```typescript\n * const passToK = calculatePassToK(0.7, 3); // ~0.343\n * ```\n */\nexport function calculatePassToK(passRate: number, k: number): number {\n  return Math.pow(passRate, k);\n}\n\n/**\n * Calculate required pass rate to achieve target pass@k\n *\n * @param targetPassAtK - Desired pass@k probability\n * @param k - Number of runs\n * @returns Required single-run pass rate\n *\n * @example\n * ```typescript\n * const requiredRate = requiredPassRateForPassAtK(0.95, 3); // ~0.632\n * ```\n */\nexport function requiredPassRateForPassAtK(targetPassAtK: number, k: number): number {\n  return 1 - Math.pow(1 - targetPassAtK, 1 / k);\n}\n\n/**\n * Determine if evaluation is reliable based on analysis\n *\n * @param analysis - Criterion analysis result\n * @param reliabilityThreshold - Minimum reliability score (default 0.8)\n * @returns Whether the evaluation is considered reliable\n */\nexport function isReliableEvaluation(\n  analysis: CriterionAnalysis,\n  reliabilityThreshold = 0.8\n): boolean {\n  return analysis.reliabilityScore >= reliabilityThreshold;\n}\n\n/**\n * Get recommendation based on reliability analysis\n *\n * @param analysis - Criterion analysis result\n * @returns Actionable recommendation string\n */\nexport function getReliabilityRecommendation(analysis: CriterionAnalysis): string {\n  if (analysis.reliabilityScore >= 0.9) {\n    return 'Evaluation is highly reliable. No changes needed.';\n  } else if (analysis.reliabilityScore >= 0.8) {\n    return 'Evaluation is reliable. Consider minor criteria refinements.';\n  } else if (analysis.reliabilityScore >= 0.6) {\n    return 'Evaluation has moderate reliability. Add more specific criteria or examples.';\n  } else {\n    return 'Evaluation is unreliable. Consider using deterministic checks or restructuring criteria.';\n  }\n}\n"]}

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';