@juspay/neurolink 9.36.1 → 9.38.0

package/dist/lib/evaluation/scorers/llm/faithfulnessScorer.js

@@ -0,0 +1,122 @@
+/**
+ * @file Faithfulness scorer
+ * Evaluates if the response is grounded in the provided context
+ */
+import { BaseLLMScorer } from "./baseLLMScorer.js";
+const FAITHFULNESS_PROMPT = `You are an expert at evaluating faithfulness in AI responses.
+
+Faithfulness measures whether the response is grounded in and supported by the provided context.
+A faithful response:
+- Only makes claims that are supported by the context
+- Does not add information not present in the context
+- Accurately represents the information from the context
+
+## Response to Evaluate
+{{response}}
+
+## Source Context
+{{context}}
+
+{{#if hasQuery}}
+## Original Query
+{{query}}
+{{/if}}
+
+## Instructions
+
+1. Extract all claims/statements from the response
+2. For each claim, determine if it's supported by the context
+3. Calculate the faithfulness score based on the proportion of supported claims
+
+## Output Format (JSON)
+
+{
+  "score": <0-10>,
+  "claims": [
+    {
+      "claim": "<extracted claim>",
+      "supported": <true|false>,
+      "evidence": "<supporting context or 'Not found in context'>"
+    }
+  ],
+  "supportedCount": <number>,
+  "totalClaims": <number>,
+  "reasoning": "<overall assessment>",
+  "confidence": <0.0-1.0>
+}`;
+export class FaithfulnessScorer extends BaseLLMScorer {
+    constructor(config) {
+        super({
+            id: "faithfulness",
+            name: "Faithfulness",
+            description: "Evaluates if the response is faithfully grounded in provided context",
+            type: "llm",
+            category: "faithfulness",
+            version: "1.0.0",
+            defaultConfig: {
+                enabled: true,
+                threshold: 0.7,
+                weight: 1.2,
+                timeout: 30000,
+                retries: 2,
+            },
+            requiredInputs: ["response", "context"],
+            optionalInputs: ["query"],
+        }, config);
+    }
+    generatePrompt(input) {
+        let prompt = FAITHFULNESS_PROMPT;
+        prompt = this.substituteTemplate(prompt, { response: input.response });
+        if (input.context && input.context.length > 0) {
+            const contextSection = input.context
+                .map((c, i) => `[Source ${i + 1}]: ${c}`)
+                .join("\n");
+            prompt = prompt.replace("{{context}}", contextSection);
+        }
+        else {
+            prompt = prompt.replace("{{context}}", "No context provided");
+        }
+        const hasQuery = !!input.query;
+        prompt = this.processConditionals(prompt, { hasQuery });
+        if (hasQuery) {
+            prompt = this.substituteTemplate(prompt, { query: input.query });
+        }
+        return prompt;
+    }
+    parseResponse(response, _input) {
+        const json = this.extractJSON(response);
+        if (!json) {
+            const score = this.extractScoreFromText(response);
+            return {
+                score,
+                reasoning: "Could not parse structured response",
+                confidence: 0.3,
+            };
+        }
+        const claims = Array.isArray(json.claims)
+            ? json.claims
+            : [];
+        const totalClaims = typeof json.totalClaims === "number" ? json.totalClaims : claims.length;
+        const supportedCount = typeof json.supportedCount === "number"
+            ? json.supportedCount
+            : claims.filter((c) => c.supported === true).length;
+        const faithfulnessRatio = totalClaims > 0 ? supportedCount / totalClaims : 1;
+        return {
+            score: typeof json.score === "number" ? json.score : faithfulnessRatio * 10,
+            reasoning: typeof json.reasoning === "string"
+                ? json.reasoning
+                : "No reasoning provided",
+            confidence: typeof json.confidence === "number" ? json.confidence : 0.8,
+            metadata: {
+                claims,
+                supportedCount,
+                totalClaims,
+                faithfulnessRatio,
+            },
+        };
+    }
+}
+export async function createFaithfulnessScorer(config) {
+    return new FaithfulnessScorer(config);
+}
+//# sourceMappingURL=faithfulnessScorer.js.map

package/dist/lib/evaluation/scorers/llm/hallucinationScorer.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @file Hallucination detection scorer using LLM-as-judge
+ * Detects factual errors and unsupported claims in AI responses
+ */
+import type { LLMScorerConfig, ScoreResult, ScorerInput } from "../../../types/scorerTypes.js";
+import { BaseLLMScorer } from "./baseLLMScorer.js";
+export declare class HallucinationScorer extends BaseLLMScorer {
+    constructor(config?: Partial<LLMScorerConfig>);
+    generatePrompt(input: ScorerInput): string;
+    parseResponse(response: string, _input: ScorerInput): Partial<ScoreResult>;
+}
+export declare function createHallucinationScorer(config?: Partial<LLMScorerConfig>): Promise<HallucinationScorer>;

package/dist/lib/evaluation/scorers/llm/hallucinationScorer.js

@@ -0,0 +1,141 @@
+/**
+ * @file Hallucination detection scorer using LLM-as-judge
+ * Detects factual errors and unsupported claims in AI responses
+ */
+import { BaseLLMScorer } from "./baseLLMScorer.js";
+const HALLUCINATION_PROMPT = `You are an expert fact-checker evaluating an AI response for hallucinations.
+
+A hallucination is when the AI:
+1. States false facts that contradict known information
+2. Fabricates specific details (names, dates, statistics) without basis
+3. Makes claims that cannot be verified or are contradicted by provided context
+4. Presents opinions or speculation as established facts
+
+## Evaluation Context
+
+**User Query:**
+{{query}}
+
+**AI Response:**
+{{response}}
+
+{{#if hasContext}}
+**Provided Context:**
+{{context}}
+{{/if}}
+
+{{#if hasGroundTruth}}
+**Ground Truth:**
+{{groundTruth}}
+{{/if}}
+
+## Instructions
+
+Analyze the response for hallucinations. For each potential hallucination found:
+1. Quote the problematic text
+2. Explain why it's a hallucination
+3. Rate severity (minor, moderate, severe)
+
+Then provide an overall score from 0-10:
+- 10: No hallucinations detected
+- 7-9: Minor issues (imprecise but not false)
+- 4-6: Moderate hallucinations present
+- 1-3: Severe hallucinations
+- 0: Response is mostly fabricated
+
+## Output Format (JSON)
+
+{
+  "score": <0-10>,
+  "hallucinations": [
+    {
+      "text": "<quoted problematic text>",
+      "reason": "<explanation>",
+      "severity": "<minor|moderate|severe>"
+    }
+  ],
+  "reasoning": "<overall assessment>",
+  "confidence": <0.0-1.0>
+}`;
+export class HallucinationScorer extends BaseLLMScorer {
+    constructor(config) {
+        super({
+            id: "hallucination",
+            name: "Hallucination Detection",
+            description: "Detects factual errors, fabrications, and unsupported claims in responses",
+            type: "llm",
+            category: "accuracy",
+            version: "1.0.0",
+            defaultConfig: {
+                enabled: true,
+                threshold: 0.8,
+                weight: 1.5,
+                timeout: 30000,
+                retries: 2,
+            },
+            requiredInputs: ["query", "response"],
+            optionalInputs: ["context", "groundTruth"],
+        }, config);
+    }
+    generatePrompt(input) {
+        let prompt = HALLUCINATION_PROMPT;
+        // Substitute variables
+        prompt = this.substituteTemplate(prompt, {
+            query: input.query,
+            response: input.response,
+        });
+        // Handle context
+        const contextExists = !!(input.context && input.context.length > 0);
+        prompt = this.processConditionals(prompt, { hasContext: contextExists });
+        if (contextExists && input.context) {
+            prompt = prompt.replace("{{context}}", input.context.map((c, i) => `[${i + 1}] ${c}`).join("\n"));
+        }
+        // Handle ground truth
+        const groundTruthExists = !!input.groundTruth;
+        prompt = this.processConditionals(prompt, {
+            hasGroundTruth: groundTruthExists,
+        });
+        if (groundTruthExists && input.groundTruth) {
+            prompt = prompt.replace("{{groundTruth}}", input.groundTruth);
+        }
+        return prompt;
+    }
+    parseResponse(response, _input) {
+        const json = this.extractJSON(response);
+        if (!json) {
+            // Try to extract score from text
+            const score = this.extractScoreFromText(response);
+            return {
+                score,
+                reasoning: "Could not parse structured response",
+                confidence: 0.3,
+            };
+        }
+        const hallucinations = Array.isArray(json.hallucinations)
+            ? json.hallucinations
+            : [];
+        const severities = hallucinations.map((h) => h.severity ?? "unknown");
+        const rawScore = typeof json.score === "number" ? json.score : 5;
+        const score = Math.max(0, Math.min(10, rawScore)); // Clamp to 0-10
+        return {
+            score,
+            reasoning: typeof json.reasoning === "string"
+                ? json.reasoning
+                : "No reasoning provided",
+            confidence: typeof json.confidence === "number" ? json.confidence : 0.8,
+            metadata: {
+                hallucinationCount: hallucinations.length,
+                hallucinations,
+                severityBreakdown: {
+                    minor: severities.filter((s) => s === "minor").length,
+                    moderate: severities.filter((s) => s === "moderate").length,
+                    severe: severities.filter((s) => s === "severe").length,
+                },
+            },
+        };
+    }
+}
+export async function createHallucinationScorer(config) {
+    return new HallucinationScorer(config);
+}
+//# sourceMappingURL=hallucinationScorer.js.map

package/dist/lib/evaluation/scorers/llm/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file LLM Scorers Index
+ * Export all LLM-based scorers
+ */
+export { AnswerRelevancyScorer, createAnswerRelevancyScorer, } from "./answerRelevancyScorer.js";
+export { BaseLLMScorer, DEFAULT_LLM_SCORER_CONFIG } from "./baseLLMScorer.js";
+export { BiasDetectionScorer, createBiasDetectionScorer, } from "./biasDetectionScorer.js";
+export { ContextPrecisionScorer, createContextPrecisionScorer, } from "./contextPrecisionScorer.js";
+export { ContextRelevancyScorer, createContextRelevancyScorer, } from "./contextRelevancyScorer.js";
+export { createFaithfulnessScorer, FaithfulnessScorer, } from "./faithfulnessScorer.js";
+export { createHallucinationScorer, HallucinationScorer, } from "./hallucinationScorer.js";
+export { createPromptAlignmentScorer, PromptAlignmentScorer, } from "./promptAlignmentScorer.js";
+export { createSummarizationScorer, SummarizationScorer, } from "./summarizationScorer.js";
+export { createToneConsistencyScorer, ToneConsistencyScorer, } from "./toneConsistencyScorer.js";
+export { createToxicityScorer, ToxicityScorer } from "./toxicityScorer.js";

package/dist/lib/evaluation/scorers/llm/index.js

@@ -0,0 +1,17 @@
+/**
+ * @file LLM Scorers Index
+ * Export all LLM-based scorers
+ */
+export { AnswerRelevancyScorer, createAnswerRelevancyScorer, } from "./answerRelevancyScorer.js";
+export { BaseLLMScorer, DEFAULT_LLM_SCORER_CONFIG } from "./baseLLMScorer.js";
+export { BiasDetectionScorer, createBiasDetectionScorer, } from "./biasDetectionScorer.js";
+export { ContextPrecisionScorer, createContextPrecisionScorer, } from "./contextPrecisionScorer.js";
+export { ContextRelevancyScorer, createContextRelevancyScorer, } from "./contextRelevancyScorer.js";
+export { createFaithfulnessScorer, FaithfulnessScorer, } from "./faithfulnessScorer.js";
+// LLM Scorers
+export { createHallucinationScorer, HallucinationScorer, } from "./hallucinationScorer.js";
+export { createPromptAlignmentScorer, PromptAlignmentScorer, } from "./promptAlignmentScorer.js";
+export { createSummarizationScorer, SummarizationScorer, } from "./summarizationScorer.js";
+export { createToneConsistencyScorer, ToneConsistencyScorer, } from "./toneConsistencyScorer.js";
+export { createToxicityScorer, ToxicityScorer } from "./toxicityScorer.js";
+//# sourceMappingURL=index.js.map

package/dist/lib/evaluation/scorers/llm/promptAlignmentScorer.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @file Prompt alignment scorer
+ * Measures how well the response aligns with prompt instructions
+ */
+import type { LLMScorerConfig, ScoreResult, ScorerInput } from "../../../types/scorerTypes.js";
+import { BaseLLMScorer } from "./baseLLMScorer.js";
+export declare class PromptAlignmentScorer extends BaseLLMScorer {
+    constructor(config?: Partial<LLMScorerConfig>);
+    generatePrompt(input: ScorerInput): string;
+    parseResponse(response: string, _input: ScorerInput): Partial<ScoreResult>;
+}
+export declare function createPromptAlignmentScorer(config?: Partial<LLMScorerConfig>): Promise<PromptAlignmentScorer>;

package/dist/lib/evaluation/scorers/llm/promptAlignmentScorer.js

@@ -0,0 +1,107 @@
+/**
+ * @file Prompt alignment scorer
+ * Measures how well the response aligns with prompt instructions
+ */
+import { BaseLLMScorer } from "./baseLLMScorer.js";
+const PROMPT_ALIGNMENT_PROMPT = `You are an expert at evaluating how well AI responses follow instructions.
+
+**User Instructions/Query:**
+{{query}}
+
+**AI Response:**
+{{response}}
+
+## Instructions
+
+Analyze how well the response follows the instructions in the query. Check for:
+
+1. **Instruction Following**: Does it do what was asked?
+2. **Format Compliance**: Does it follow requested format?
+3. **Constraint Adherence**: Does it respect any constraints given?
+4. **Completeness**: Does it address all parts of the request?
+5. **No Hallucinated Instructions**: Does it avoid adding unrequested content?
+
+## Output Format (JSON)
+
+{
+  "score": <0-10>,
+  "instructionFollowing": {
+    "score": <0-10>,
+    "details": "<explanation>"
+  },
+  "formatCompliance": {
+    "score": <0-10>,
+    "details": "<explanation>"
+  },
+  "constraintAdherence": {
+    "score": <0-10>,
+    "details": "<explanation>"
+  },
+  "completeness": {
+    "score": <0-10>,
+    "details": "<explanation>"
+  },
+  "missedInstructions": ["<list of missed requirements>"],
+  "extraContent": ["<list of unrequested content>"],
+  "reasoning": "<overall assessment>",
+  "confidence": <0.0-1.0>
+}`;
+export class PromptAlignmentScorer extends BaseLLMScorer {
+    constructor(config) {
+        super({
+            id: "prompt-alignment",
+            name: "Prompt Alignment",
+            description: "Measures how well the response aligns with prompt instructions",
+            type: "llm",
+            category: "quality",
+            version: "1.0.0",
+            defaultConfig: {
+                enabled: true,
+                threshold: 0.7,
+                weight: 1.0,
+                timeout: 25000,
+                retries: 2,
+            },
+            requiredInputs: ["query", "response"],
+            optionalInputs: [],
+        }, config);
+    }
+    generatePrompt(input) {
+        return this.substituteTemplate(PROMPT_ALIGNMENT_PROMPT, {
+            query: input.query,
+            response: input.response,
+        });
+    }
+    parseResponse(response, _input) {
+        const json = this.extractJSON(response);
+        if (!json) {
+            const score = this.extractScoreFromText(response);
+            return {
+                score,
+                reasoning: "Could not parse structured response",
+                confidence: 0.3,
+            };
+        }
+        const score = Math.min(10, Math.max(0, typeof json.score === "number" ? json.score : 5));
+        const confidence = Math.min(1, Math.max(0, typeof json.confidence === "number" ? json.confidence : 0.8));
+        return {
+            score,
+            reasoning: typeof json.reasoning === "string"
+                ? json.reasoning
+                : "No reasoning provided",
+            confidence,
+            metadata: {
+                instructionFollowing: json.instructionFollowing ?? null,
+                formatCompliance: json.formatCompliance ?? null,
+                constraintAdherence: json.constraintAdherence ?? null,
+                completeness: json.completeness ?? null,
+                missedInstructions: json.missedInstructions ?? [],
+                extraContent: json.extraContent ?? [],
+            },
+        };
+    }
+}
+export async function createPromptAlignmentScorer(config) {
+    return new PromptAlignmentScorer(config);
+}
+//# sourceMappingURL=promptAlignmentScorer.js.map

package/dist/lib/evaluation/scorers/llm/summarizationScorer.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @file Summarization quality scorer
+ * Evaluates the quality of AI-generated summaries
+ */
+import type { LLMScorerConfig, ScoreResult, ScorerInput } from "../../../types/scorerTypes.js";
+import { BaseLLMScorer } from "./baseLLMScorer.js";
+export declare class SummarizationScorer extends BaseLLMScorer {
+    constructor(config?: Partial<LLMScorerConfig>);
+    generatePrompt(input: ScorerInput): string;
+    parseResponse(response: string, _input: ScorerInput): Partial<ScoreResult>;
+}
+export declare function createSummarizationScorer(config?: Partial<LLMScorerConfig>): Promise<SummarizationScorer>;

package/dist/lib/evaluation/scorers/llm/summarizationScorer.js

@@ -0,0 +1,115 @@
+/**
+ * @file Summarization quality scorer
+ * Evaluates the quality of AI-generated summaries
+ */
+import { BaseLLMScorer } from "./baseLLMScorer.js";
+const SUMMARIZATION_PROMPT = `You are an expert at evaluating summary quality.
+
+**Summary to Evaluate:**
+{{response}}
+
+**Original Content:**
+{{context}}
+
+{{#if hasQuery}}
+**Summarization Request:**
+{{query}}
+{{/if}}
+
+## Evaluation Criteria
+
+1. **Accuracy**: Is the summary factually correct?
+2. **Coverage**: Does it capture the key points?
+3. **Conciseness**: Is it appropriately brief?
+4. **Coherence**: Is it well-organized and readable?
+5. **No Hallucinations**: Does it avoid adding new information?
+
+## Output Format (JSON)
+
+{
+  "score": <0-10>,
+  "accuracy": {
+    "score": <0-10>,
+    "errors": ["<list of factual errors>"]
+  },
+  "coverage": {
+    "score": <0-10>,
+    "keyPointsCovered": ["<covered points>"],
+    "keyPointsMissed": ["<missed points>"]
+  },
+  "conciseness": {
+    "score": <0-10>,
+    "assessment": "<too long|appropriate|too short>"
+  },
+  "coherence": {
+    "score": <0-10>,
+    "issues": ["<any coherence issues>"]
+  },
+  "hallucinations": ["<any fabricated information>"],
+  "reasoning": "<overall assessment>",
+  "confidence": <0.0-1.0>
+}`;
+export class SummarizationScorer extends BaseLLMScorer {
+    constructor(config) {
+        super({
+            id: "summarization",
+            name: "Summarization Quality",
+            description: "Evaluates the quality of AI-generated summaries",
+            type: "llm",
+            category: "quality",
+            version: "1.0.0",
+            defaultConfig: {
+                enabled: true,
+                threshold: 0.7,
+                weight: 1.0,
+                timeout: 25000,
+                retries: 2,
+            },
+            requiredInputs: ["response", "context"],
+            optionalInputs: ["query"],
+        }, config);
+    }
+    generatePrompt(input) {
+        let prompt = SUMMARIZATION_PROMPT;
+        const hasQuery = !!input.query;
+        prompt = this.processConditionals(prompt, { hasQuery });
+        return this.substituteTemplate(prompt, {
+            response: input.response,
+            context: input.context?.join("\n\n") ?? "",
+            query: hasQuery ? input.query : "",
+        });
+    }
+    parseResponse(response, _input) {
+        const json = this.extractJSON(response);
+        if (!json) {
+            const score = this.extractScoreFromText(response);
+            return {
+                score,
+                reasoning: "Could not parse structured response",
+                confidence: 0.3,
+            };
+        }
+        const score = Math.min(10, Math.max(0, typeof json.score === "number"
+            ? json.score
+            : this.extractScoreFromText(response)));
+        const confidence = Math.min(1, Math.max(0, typeof json.confidence === "number" ? json.confidence : 0.3));
+        return {
+            score,
+            reasoning: typeof json.reasoning === "string"
+                ? json.reasoning
+                : "No reasoning provided",
+            confidence,
+            metadata: {
+                accuracy: json.accuracy ?? null,
+                coverage: json.coverage ?? null,
+                conciseness: json.conciseness ?? null,
+                coherence: json.coherence ?? null,
+                hallucinations: json.hallucinations ?? [],
+            },
+        };
+    }
+}
+export async function createSummarizationScorer(config) {
+    return new SummarizationScorer(config);
+}
+//# sourceMappingURL=summarizationScorer.js.map

package/dist/lib/evaluation/scorers/llm/toneConsistencyScorer.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @file Tone consistency scorer
+ * Checks for consistent tone throughout the response
+ */
+import type { LLMScorerConfig, ScoreResult, ScorerInput } from "../../../types/scorerTypes.js";
+import { BaseLLMScorer } from "./baseLLMScorer.js";
+export declare class ToneConsistencyScorer extends BaseLLMScorer {
+    constructor(config?: Partial<LLMScorerConfig>);
+    generatePrompt(input: ScorerInput): string;
+    parseResponse(response: string, _input: ScorerInput): Partial<ScoreResult>;
+}
+export declare function createToneConsistencyScorer(config?: Partial<LLMScorerConfig>): Promise<ToneConsistencyScorer>;

package/dist/lib/evaluation/scorers/llm/toneConsistencyScorer.js

@@ -0,0 +1,107 @@
+/**
+ * @file Tone consistency scorer
+ * Checks for consistent tone throughout the response
+ */
+import { BaseLLMScorer } from "./baseLLMScorer.js";
+const TONE_CONSISTENCY_PROMPT = `You are an expert at analyzing writing tone and style consistency.
+
+{{#if hasQuery}}
+**User Query:**
+{{query}}
+{{/if}}
+
+**AI Response:**
+{{response}}
+
+## Instructions
+
+Analyze the response for tone consistency. Check for:
+1. Consistent formality level throughout
+2. Consistent emotional tone
+3. Consistent voice (e.g., professional, casual, friendly)
+4. No jarring shifts in style
+5. Appropriate tone for the context
+
+## Output Format (JSON)
+
+{
+  "score": <0-10>,
+  "dominantTone": "<identified main tone>",
+  "formalityLevel": "<formal|semi-formal|casual|mixed>",
+  "toneShifts": [
+    {
+      "location": "<beginning|middle|end>",
+      "from": "<original tone>",
+      "to": "<shifted tone>",
+      "severity": "<minor|moderate|major>"
+    }
+  ],
+  "reasoning": "<detailed assessment>",
+  "confidence": <0.0-1.0>
+}`;
+export class ToneConsistencyScorer extends BaseLLMScorer {
+    constructor(config) {
+        super({
+            id: "tone-consistency",
+            name: "Tone Consistency",
+            description: "Checks for consistent tone throughout the response",
+            type: "llm",
+            category: "quality",
+            version: "1.0.0",
+            defaultConfig: {
+                enabled: true,
+                threshold: 0.7,
+                weight: 0.8,
+                timeout: 20000,
+                retries: 1,
+            },
+            requiredInputs: ["response"],
+            optionalInputs: ["query"],
+        }, config);
+    }
+    generatePrompt(input) {
+        let prompt = TONE_CONSISTENCY_PROMPT;
+        const hasQuery = !!input.query;
+        prompt = this.processConditionals(prompt, { hasQuery });
+        if (hasQuery) {
+            prompt = this.substituteTemplate(prompt, { query: input.query });
+        }
+        prompt = this.substituteTemplate(prompt, { response: input.response });
+        return prompt;
+    }
+    parseResponse(response, _input) {
+        const json = this.extractJSON(response);
+        if (!json) {
+            const score = this.extractScoreFromText(response);
+            return {
+                score,
+                reasoning: "Could not parse structured response",
+                confidence: 0.3,
+            };
+        }
+        const toneShifts = Array.isArray(json.toneShifts)
+            ? json.toneShifts
+            : [];
+        const score = typeof json.score === "number"
+            ? json.score
+            : this.extractScoreFromText(response);
+        const confidence = typeof json.confidence === "number" ? json.confidence : 0.3;
+        return {
+            score,
+            reasoning: typeof json.reasoning === "string"
+                ? json.reasoning
+                : "Could not parse structured response",
+            confidence,
+            metadata: {
+                dominantTone: json.dominantTone ?? "unknown",
+                formalityLevel: json.formalityLevel ?? "unknown",
+                toneShifts,
+                shiftCount: toneShifts.length,
+            },
+        };
+    }
+}
+export async function createToneConsistencyScorer(config) {
+    return new ToneConsistencyScorer(config);
+}
+//# sourceMappingURL=toneConsistencyScorer.js.map