@mastra/evals 0.13.1 → 0.13.3-alpha.0

package/dist/scorers/llm/index.js

@@ -1,5 +1,5 @@
 import { roundToTwoDecimals } from '../../chunk-QTWX6TKR.js';
-import { getAssistantMessageFromRunOutput, getUserMessageFromRunInput, roundToTwoDecimals as roundToTwoDecimals$1, extractToolCalls } from '../../chunk-5CVZXIFW.js';
+import { getAssistantMessageFromRunOutput, getUserMessageFromRunInput, roundToTwoDecimals as roundToTwoDecimals$1, extractToolCalls, getCombinedSystemPrompt } from '../../chunk-4LRZVFXR.js';
 import { createScorer } from '@mastra/core/scores';
 import { z } from 'zod';
 
@@ -1097,7 +1097,7 @@ var analyzeOutputSchema = z.object({
   missingTools: z.array(z.string()).optional()
 });
 function createToolCallAccuracyScorerLLM({ model, availableTools }) {
-  const toolDefinitions = availableTools.map((tool) => `${tool.name}: ${tool.description}`).join("\n");
+  const toolDefinitions = availableTools.map((tool) => `${tool.id}: ${tool.description}`).join("\n");
   return createScorer({
     name: "Tool Call Accuracy (LLM)",
     description: "Evaluates whether an agent selected appropriate tools for the given task using LLM analysis",
@@ -1156,6 +1156,1140 @@ function createToolCallAccuracyScorerLLM({ model, availableTools }) {
   });
 }
 
-export { ANSWER_RELEVANCY_AGENT_INSTRUCTIONS, DEFAULT_OPTIONS, createAnswerRelevancyScorer, createBiasScorer, createFaithfulnessScorer, createHallucinationScorer, createToolCallAccuracyScorerLLM, createToxicityScorer };
+// src/scorers/llm/context-relevance/prompts.ts
+var CONTEXT_RELEVANCE_INSTRUCTIONS = `You are an expert context relevance evaluator. Your job is to analyze whether the provided context information was appropriate and useful for generating the agent's response to the user's query.
+
+Key Evaluation Criteria:
+1. **Relevance**: Does the context directly relate to the user's query?
+2. **Utility**: Did the context help produce a better response?
+3. **Completeness**: Was the context sufficient for the task?
+4. **Quality**: Is the context accurate and trustworthy?
+
+Evaluation Guidelines:
+- Context that directly answers or supports the user's query should be marked as highly relevant
+- Context that provides background information relevant to the query should be considered moderately relevant  
+- Context that is tangentially related but doesn't directly help should be marked as low relevance
+- Context that is completely unrelated should be marked as irrelevant
+- Consider whether missing context might have led to a better response
+
+Be thorough and fair in your evaluation, considering both what context was provided and what might have been more useful.`;
+function createAnalyzePrompt2({
+  userQuery,
+  agentResponse,
+  providedContext
+}) {
+  const contextList = providedContext.map((ctx, index) => `[${index}] ${ctx}`).join("\n");
+  return `Analyze the relevance of the provided context for answering the user's query and generating the agent's response.
+
+User Query:
+${userQuery}
+
+Agent Response:
+${agentResponse}
+
+Context pieces to evaluate:
+${contextList}
+
+For each context piece, evaluate:
+1. **Relevance Level**: How relevant is it to the user's query?
+   - "high": Directly addresses the query or provides essential information
+   - "medium": Provides supporting or background information that's helpful
+   - "low": Tangentially related but not very helpful
+   - "none": Completely irrelevant or unrelated
+
+2. **Usage**: Was this context actually used in generating the agent's response?
+   - true: The response clearly incorporates or reflects this information
+   - false: This information doesn't appear to be used in the response
+
+3. **Reasoning**: Explain your assessment in detail
+
+Also identify any missing context that should have been provided to better answer the query.
+
+Format your response as:
+{
+  "evaluations": [
+    {
+      "context_index": 0,
+      "contextPiece": "the actual text of the context piece",
+      "relevanceLevel": "high/medium/low/none", 
+      "wasUsed": true/false,
+      "reasoning": "detailed explanation of the evaluation"
+    }
+  ],
+  "missingContext": ["list of missing information that would have been helpful"],
+  "overallAssessment": "summary of the context quality and usage"
+}
+
+The number of evaluations MUST match the number of context pieces exactly.
+
+Example:
+User Query: "What are the benefits of exercise?"
+Agent Response: "Regular exercise improves cardiovascular health and mental wellbeing."
+Context:
+[0] "Exercise strengthens the heart and improves blood circulation."
+[1] "A balanced diet is important for overall health."
+[2] "Regular physical activity reduces stress and anxiety levels."
+
+{
+  "evaluations": [
+    {
+      "context_index": 0,
+      "contextPiece": "Exercise strengthens the heart and improves blood circulation.",
+      "relevanceLevel": "high",
+      "wasUsed": true,
+      "reasoning": "This context directly supports the cardiovascular health benefit mentioned in the response"
+    },
+    {
+      "context_index": 1,
+      "contextPiece": "A balanced diet is important for overall health.",
+      "relevanceLevel": "none",
+      "wasUsed": false,
+      "reasoning": "This context is about diet, not exercise benefits, and doesn't contribute to answering the query"
+    },
+    {
+      "context_index": 2,
+      "contextPiece": "Regular physical activity reduces stress and anxiety levels.",
+      "relevanceLevel": "high", 
+      "wasUsed": true,
+      "reasoning": "This context directly supports the mental wellbeing benefit mentioned in the response"
+    }
+  ],
+  "missingContext": [],
+  "overallAssessment": "The context is mostly high-quality with 2 out of 3 pieces being highly relevant and used in the response"
+}`;
+}
+function createReasonPrompt3({
+  userQuery,
+  score,
+  evaluations,
+  missingContext,
+  scale
+}) {
+  return `Explain the context relevance score for the provided context based on its relevance and usage in generating the agent's response.
+
+User Query:
+${userQuery}
+
+Score: ${score} out of ${scale}
+
+Context Evaluations:
+${evaluations.map(
+    (evaluation) => `[${evaluation.context_index}] Relevance: ${evaluation.relevanceLevel}, Used: ${evaluation.wasUsed ? "Yes" : "No"}
+   Context: "${evaluation.contextPiece}"
+   Reasoning: ${evaluation.reasoning}`
+  ).join("\n\n")}
+
+${missingContext.length > 0 ? `
+Missing Context Issues:
+${missingContext.map((item) => `- ${item}`).join("\n")}` : ""}
+
+Context Relevance measures how well the provided context supports answering the user's query and generating the expected response. The score considers:
+- Relevance levels (high=1.0, medium=0.7, low=0.3, none=0.0)
+- Usage penalties (10% penalty per unused high-relevance context)
+- Missing context penalties (up to 50% penalty for identified gaps)
+
+Rules for explanation:
+- Explain the score based on context relevance levels and usage
+- Mention any penalties applied for unused relevant context or missing information
+- Keep explanation concise and actionable for improving context selection
+- Use the given score, don't recalculate
+
+Format:
+"The score is ${score} because {explanation of context relevance, usage, and any penalties}"
+
+Example responses:
+"The score is 0.85 because 2 out of 3 context pieces are highly relevant and used in the response, with only minor penalty for one unused medium-relevance context piece."
+"The score is 1.0 because all context pieces are highly relevant to the query about exercise benefits and were effectively used in generating the comprehensive response."
+"The score is 0.40 because while some context is relevant, key information about the topic was missing and one highly relevant context piece was not utilized in the response."`;
+}
+
+// src/scorers/llm/context-relevance/index.ts
+var analyzeOutputSchema2 = z.object({
+  evaluations: z.array(
+    z.object({
+      context_index: z.number(),
+      contextPiece: z.string(),
+      relevanceLevel: z.enum(["high", "medium", "low", "none"]),
+      wasUsed: z.boolean(),
+      reasoning: z.string()
+    })
+  ),
+  missingContext: z.array(z.string()).optional().default([]),
+  overallAssessment: z.string()
+});
+var DEFAULT_PENALTIES = {
+  UNUSED_HIGH_RELEVANCE_CONTEXT: 0.1,
+  // 10% penalty per unused high-relevance context
+  MISSING_CONTEXT_PER_ITEM: 0.15,
+  // 15% penalty per missing context item
+  MAX_MISSING_CONTEXT_PENALTY: 0.5
+  // Maximum 50% penalty for missing context
+};
+function createContextRelevanceScorerLLM({
+  model,
+  options
+}) {
+  if (!options.context && !options.contextExtractor) {
+    throw new Error("Either context or contextExtractor is required for Context Relevance scoring");
+  }
+  if (options.context && options.context.length === 0) {
+    throw new Error("Context array cannot be empty if provided");
+  }
+  return createScorer({
+    name: "Context Relevance (LLM)",
+    description: "Evaluates how relevant and useful the provided context was for generating the agent response",
+    judge: {
+      model,
+      instructions: CONTEXT_RELEVANCE_INSTRUCTIONS
+    }
+  }).analyze({
+    description: "Analyze the relevance and utility of provided context",
+    outputSchema: analyzeOutputSchema2,
+    createPrompt: ({ run }) => {
+      const userQuery = getUserMessageFromRunInput(run.input) ?? "";
+      const agentResponse = getAssistantMessageFromRunOutput(run.output) ?? "";
+      const context = options.contextExtractor ? options.contextExtractor(run.input, run.output) : options.context;
+      if (context.length === 0) {
+        return createAnalyzePrompt2({
+          userQuery,
+          agentResponse,
+          providedContext: ["[No context was provided for evaluation]"]
+        });
+      }
+      return createAnalyzePrompt2({
+        userQuery,
+        agentResponse,
+        providedContext: context
+      });
+    }
+  }).generateScore(({ results, run }) => {
+    const evaluations = results.analyzeStepResult?.evaluations || [];
+    const context = options.contextExtractor ? options.contextExtractor(run.input, run.output) : options.context;
+    if (context.length === 0) {
+      return 1 * (options.scale || 1);
+    }
+    if (evaluations.length === 0) {
+      const missingContext2 = results.analyzeStepResult?.missingContext || [];
+      return missingContext2.length > 0 ? 0 : 1;
+    }
+    const relevanceWeights = {
+      high: 1,
+      medium: 0.7,
+      low: 0.3,
+      none: 0
+    };
+    const totalWeight = evaluations.reduce((sum, evaluation) => {
+      return sum + relevanceWeights[evaluation.relevanceLevel];
+    }, 0);
+    const maxPossibleWeight = evaluations.length * relevanceWeights.high;
+    const relevanceScore = maxPossibleWeight > 0 ? totalWeight / maxPossibleWeight : 0;
+    const highRelevanceUnused = evaluations.filter(
+      (evaluation) => evaluation.relevanceLevel === "high" && !evaluation.wasUsed
+    ).length;
+    const penalties = options.penalties || {};
+    const unusedPenaltyRate = penalties.unusedHighRelevanceContext ?? DEFAULT_PENALTIES.UNUSED_HIGH_RELEVANCE_CONTEXT;
+    const missingPenaltyRate = penalties.missingContextPerItem ?? DEFAULT_PENALTIES.MISSING_CONTEXT_PER_ITEM;
+    const maxMissingPenalty = penalties.maxMissingContextPenalty ?? DEFAULT_PENALTIES.MAX_MISSING_CONTEXT_PENALTY;
+    const usagePenalty = highRelevanceUnused * unusedPenaltyRate;
+    const missingContext = results.analyzeStepResult?.missingContext || [];
+    const missingContextPenalty = Math.min(missingContext.length * missingPenaltyRate, maxMissingPenalty);
+    const finalScore = Math.max(0, relevanceScore - usagePenalty - missingContextPenalty);
+    const scaledScore = finalScore * (options.scale || 1);
+    return roundToTwoDecimals$1(scaledScore);
+  }).generateReason({
+    description: "Generate human-readable explanation of context relevance evaluation",
+    createPrompt: ({ run, results, score }) => {
+      const userQuery = getUserMessageFromRunInput(run.input) ?? "";
+      const context = options.contextExtractor ? options.contextExtractor(run.input, run.output) : options.context;
+      if (context.length === 0) {
+        return `No context was available for evaluation. The agent response was generated without any supporting context. Score: ${score}`;
+      }
+      const evaluations = results.analyzeStepResult?.evaluations || [];
+      const missingContext = results.analyzeStepResult?.missingContext || [];
+      return createReasonPrompt3({
+        userQuery,
+        score,
+        evaluations,
+        missingContext,
+        scale: options.scale || 1
+      });
+    }
+  });
+}
+
+// src/scorers/llm/context-precision/prompts.ts
+var CONTEXT_PRECISION_AGENT_INSTRUCTIONS = `You are a precise context precision evaluator. Your job is to determine if context nodes are relevant for generating the expected output based on the input query.
+
+Key Principles:
+1. Evaluate each context piece independently for relevance to the input-output pair
+2. Consider relevance as the ability of the context to contribute to generating the expected output
+3. Mark context as relevant only if it directly supports or informs the expected output
+4. Consider the input query when determining relevance
+5. Focus on practical utility for output generation, not just topical similarity
+6. Be strict in your evaluation - context must be clearly useful for generating the output
+7. Context that provides background but doesn't directly contribute should be marked as not relevant`;
+function createContextRelevancePrompt({
+  input,
+  output,
+  context
+}) {
+  return `Evaluate the relevance of each context piece for generating the expected output given the input query.
+
+Input Query:
+${input}
+
+Expected Output:
+${output}
+
+Context pieces to evaluate:
+${context.map((ctx, index) => `[${index}] ${ctx}`).join("\n")}
+
+For each context piece, determine if it is relevant for generating the expected output. A context piece is relevant if:
+- It provides information that directly supports or informs the expected output
+- It contains facts, data, or details that are needed to answer the input query
+- It contributes to the accuracy or completeness of the expected output
+
+Mark as "yes" only if the context piece is clearly useful for generating the output.
+Mark as "no" if the context piece does not contribute to generating the expected output.
+
+Format your response as:
+{
+  "verdicts": [
+    {
+      "context_index": 0,
+      "verdict": "yes/no",
+      "reason": "explanation of why this context is or isn't relevant"
+    }
+  ]
+}
+
+The number of verdicts MUST match the number of context pieces exactly.
+
+Example:
+Input: "What are the benefits of exercise?"
+Output: "Regular exercise improves cardiovascular health and mental wellbeing."
+Context: 
+[0] "Exercise strengthens the heart and improves blood circulation."
+[1] "A balanced diet is important for health."
+[2] "Regular physical activity reduces stress and anxiety."
+
+{
+  "verdicts": [
+    {
+      "context_index": 0,
+      "verdict": "yes",
+      "reason": "This context directly supports the cardiovascular health benefit mentioned in the output"
+    },
+    {
+      "context_index": 1,
+      "verdict": "no", 
+      "reason": "This context is about diet, not exercise benefits, and doesn't contribute to the expected output"
+    },
+    {
+      "context_index": 2,
+      "verdict": "yes",
+      "reason": "This context directly supports the mental wellbeing benefit mentioned in the output"
+    }
+  ]
+}`;
+}
+function createContextPrecisionReasonPrompt({
+  input,
+  output,
+  context,
+  score,
+  scale,
+  verdicts
+}) {
+  return `Explain the context precision score for the retrieved context based on its relevance to generating the expected output.
+
+Input Query:
+${input}
+
+Expected Output:
+${output}
+
+Context pieces:
+${context.map((ctx, index) => `[${index}] ${ctx}`).join("\n")}
+
+Score: ${score} out of ${scale}
+Verdicts:
+${JSON.stringify(verdicts, null, 2)}
+
+Context Precision measures how relevant and precise the retrieved context nodes are for generating the expected output. The score is calculated using Mean Average Precision (MAP) which:
+- Gives binary relevance scores (1 for relevant, 0 for irrelevant)  
+- Weights earlier positions more heavily in the scoring
+- Rewards having relevant context early in the sequence
+
+Rules for explanation:
+- Explain the score based on which context pieces were relevant and their positions
+- Mention how the positioning affects the MAP score
+- Keep explanation concise and focused on context quality
+- Use the given score, don't recalculate
+- Focus on how well the context supports generating the expected output
+
+Format:
+"The score is ${score} because {explanation of context precision and positioning}"
+
+Example responses:
+"The score is 0.75 because the first and third contexts are highly relevant to the benefits mentioned in the output, while the second and fourth contexts are not directly related to exercise benefits. The relevant contexts are well-positioned at the beginning and middle of the sequence."
+"The score is 1.0 because all context pieces are relevant for generating the expected output and are optimally ordered."
+"The score is 0.33 because only the first context piece is relevant to the query, and the remaining contexts don't contribute to generating the expected output about exercise benefits."`;
+}
+
+// src/scorers/llm/context-precision/index.ts
+var contextRelevanceOutputSchema = z.object({
+  verdicts: z.array(
+    z.object({
+      context_index: z.number(),
+      verdict: z.string(),
+      reason: z.string()
+    })
+  )
+});
+function createContextPrecisionScorer({
+  model,
+  options
+}) {
+  if (!options.context && !options.contextExtractor) {
+    throw new Error("Either context or contextExtractor is required for Context Precision scoring");
+  }
+  if (options.context && options.context.length === 0) {
+    throw new Error("Context array cannot be empty if provided");
+  }
+  return createScorer({
+    name: "Context Precision Scorer",
+    description: "A scorer that evaluates the relevance and precision of retrieved context nodes for generating expected outputs",
+    judge: {
+      model,
+      instructions: CONTEXT_PRECISION_AGENT_INSTRUCTIONS
+    }
+  }).analyze({
+    description: "Evaluate the relevance of each context piece for generating the expected output",
+    outputSchema: contextRelevanceOutputSchema,
+    createPrompt: ({ run }) => {
+      const input = getUserMessageFromRunInput(run.input) ?? "";
+      const output = getAssistantMessageFromRunOutput(run.output) ?? "";
+      const context = options.contextExtractor ? options.contextExtractor(run.input, run.output) : options.context;
+      if (context.length === 0) {
+        throw new Error("No context available for evaluation");
+      }
+      return createContextRelevancePrompt({
+        input,
+        output,
+        context
+      });
+    }
+  }).generateScore(({ results }) => {
+    if (!results.analyzeStepResult || results.analyzeStepResult.verdicts.length === 0) {
+      return 0;
+    }
+    const verdicts = results.analyzeStepResult.verdicts;
+    const sortedVerdicts = verdicts.sort((a, b) => a.context_index - b.context_index);
+    let sumPrecision = 0;
+    let relevantCount = 0;
+    for (let i = 0; i < sortedVerdicts.length; i++) {
+      const targetVerdict = sortedVerdicts[i];
+      const isRelevant = targetVerdict?.verdict?.toLowerCase().trim() === "yes";
+      if (isRelevant) {
+        relevantCount++;
+        const precisionAtI = relevantCount / (i + 1);
+        sumPrecision += precisionAtI;
+      }
+    }
+    if (relevantCount === 0) {
+      return 0;
+    }
+    const map = sumPrecision / relevantCount;
+    const score = map * (options.scale || 1);
+    return roundToTwoDecimals$1(score);
+  }).generateReason({
+    description: "Reason about the context precision results",
+    createPrompt: ({ run, results, score }) => {
+      const input = getUserMessageFromRunInput(run.input) ?? "";
+      const output = getAssistantMessageFromRunOutput(run.output) ?? "";
+      const context = options.contextExtractor ? options.contextExtractor(run.input, run.output) : options.context;
+      return createContextPrecisionReasonPrompt({
+        input,
+        output,
+        context,
+        score,
+        scale: options.scale || 1,
+        verdicts: results.analyzeStepResult?.verdicts || []
+      });
+    }
+  });
+}
+
+// src/scorers/llm/noise-sensitivity/prompts.ts
+var NOISE_SENSITIVITY_INSTRUCTIONS = `You are an expert noise sensitivity evaluator. Your job is to analyze how much irrelevant, distracting, or misleading information (noise) affected the agent's response quality and accuracy.
+
+Key Evaluation Criteria:
+1. **Response Consistency**: How similar are the baseline and noisy responses in content and correctness?
+2. **Information Integrity**: Did the agent maintain accuracy despite noise, or was it misled?
+3. **Focus Preservation**: Did the agent stay on topic or get distracted by irrelevant information?
+4. **Hallucination Resistance**: Did noise cause the agent to generate false or fabricated information?
+5. **Completeness**: Did noise cause the agent to miss important parts of the original query?
+
+Noise Impact Assessment:
+- **No Impact (1.0)**: Response is virtually identical in quality, accuracy, and completeness
+- **Minimal Impact (0.8-0.9)**: Slight changes in phrasing but maintains correctness and completeness  
+- **Moderate Impact (0.5-0.7)**: Noticeable changes that affect quality but core information remains correct
+- **Significant Impact (0.2-0.4)**: Major degradation in quality, accuracy, or completeness
+- **Severe Impact (0.0-0.1)**: Response is substantially worse, incorrect, or completely derailed
+
+Be thorough in comparing both responses and identifying specific ways the noise affected the agent's performance.`;
+function createAnalyzePrompt3({
+  userQuery,
+  baselineResponse,
+  noisyQuery,
+  noisyResponse,
+  noiseType
+}) {
+  return `Analyze how the added noise affected the agent's response quality and accuracy.
+
+Original User Query:
+${userQuery}
+
+Baseline Agent Response (clean input):
+${baselineResponse}
+
+Noisy User Query (with added distractions):
+${noisyQuery}
+
+Noisy Agent Response:
+${noisyResponse}
+
+${noiseType ? `Type of noise added: ${noiseType}` : ""}
+
+Compare the baseline and noisy responses across these dimensions:
+
+1. **Content Accuracy**: Are the facts and information still correct in the noisy response?
+2. **Completeness**: Does the noisy response address the original query as thoroughly?
+3. **Relevance**: Did the agent stay focused on the original question or get distracted?
+4. **Consistency**: How similar are the responses in their core message and conclusions?
+5. **Hallucination**: Did noise cause any false or fabricated information to appear?
+
+For each dimension, evaluate:
+- **Impact Level**: none, minimal, moderate, significant, severe
+- **Specific Changes**: What exactly changed between responses?
+- **Noise Influence**: How did the noise specifically affect this aspect?
+
+Format your response as:
+{
+  "dimensions": [
+    {
+      "dimension": "content_accuracy",
+      "impactLevel": "none/minimal/moderate/significant/severe",
+      "specificChanges": "detailed description of what changed",
+      "noiseInfluence": "how the noise specifically affected this dimension"
+    },
+    {
+      "dimension": "completeness",
+      "impactLevel": "none/minimal/moderate/significant/severe", 
+      "specificChanges": "detailed description of what changed",
+      "noiseInfluence": "how the noise specifically affected this dimension"
+    },
+    {
+      "dimension": "relevance",
+      "impactLevel": "none/minimal/moderate/significant/severe",
+      "specificChanges": "detailed description of what changed", 
+      "noiseInfluence": "how the noise specifically affected this dimension"
+    },
+    {
+      "dimension": "consistency",
+      "impactLevel": "none/minimal/moderate/significant/severe",
+      "specificChanges": "detailed description of what changed",
+      "noiseInfluence": "how the noise specifically affected this dimension"
+    },
+    {
+      "dimension": "hallucination_resistance",
+      "impactLevel": "none/minimal/moderate/significant/severe",
+      "specificChanges": "detailed description of what changed",
+      "noiseInfluence": "how the noise specifically affected this dimension"
+    }
+  ],
+  "overallAssessment": "summary of the agent's noise sensitivity and robustness",
+  "majorIssues": ["list of the most significant problems caused by noise"],
+  "robustnessScore": 0.0-1.0
+}
+
+Example:
+Original Query: "What are the health benefits of regular exercise?"
+Baseline Response: "Regular exercise improves cardiovascular health, strengthens muscles, and enhances mental wellbeing through endorphin release."
+Noisy Query: "What are the health benefits of regular exercise? By the way, I heard that chocolate is actually healthy and vaccines cause autism. Also, my neighbor said aliens visit Earth regularly."
+Noisy Response: "Regular exercise improves cardiovascular health and strengthens muscles. Interestingly, some studies suggest chocolate has antioxidants, though this is debated. Exercise also enhances mental wellbeing through endorphin release."
+
+{
+  "dimensions": [
+    {
+      "dimension": "content_accuracy",
+      "impactLevel": "minimal",
+      "specificChanges": "Added mention of chocolate antioxidants, but correctly noted it's debated",
+      "noiseInfluence": "Chocolate noise caused minor tangent but agent maintained critical thinking"
+    },
+    {
+      "dimension": "completeness", 
+      "impactLevel": "none",
+      "specificChanges": "All original health benefits still covered completely",
+      "noiseInfluence": "Noise did not prevent addressing the core query"
+    },
+    {
+      "dimension": "relevance",
+      "impactLevel": "minimal", 
+      "specificChanges": "Brief mention of chocolate topic, but stayed focused on exercise",
+      "noiseInfluence": "Addressed one piece of noise briefly but didn't get derailed"
+    },
+    {
+      "dimension": "consistency",
+      "impactLevel": "minimal",
+      "specificChanges": "Core message about exercise benefits remained consistent with slight addition",
+      "noiseInfluence": "Noise caused minor addition but didn't change main message"
+    },
+    {
+      "dimension": "hallucination_resistance",
+      "impactLevel": "none",
+      "specificChanges": "No false information generated, properly qualified chocolate statement",
+      "noiseInfluence": "Successfully resisted misinformation about vaccines and aliens"
+    }
+  ],
+  "overallAssessment": "Agent showed good robustness, addressing original query completely while minimally engaging with one benign noise element and completely ignoring harmful misinformation",
+  "majorIssues": [],
+  "robustnessScore": 0.85
+}`;
+}
+function createReasonPrompt4({
+  userQuery,
+  score,
+  dimensions,
+  majorIssues,
+  overallAssessment
+}) {
+  const impactSummary = dimensions.map((d) => `${d.dimension}: ${d.impactLevel} impact`).join(", ");
+  return `Explain the noise sensitivity score based on how well the agent maintained response quality despite irrelevant or distracting information.
+
+Original Query:
+${userQuery}
+
+Score: ${score} out of 1.0
+
+Impact Assessment:
+${impactSummary}
+
+${majorIssues.length > 0 ? `
+Major Issues Identified:
+${majorIssues.map((issue) => `- ${issue}`).join("\n")}` : ""}
+
+Overall Assessment:
+${overallAssessment}
+
+Noise Sensitivity measures how robust an agent is when irrelevant, misleading, or distracting information is added to the input. The score considers:
+- Content accuracy preservation (maintaining factual correctness)
+- Completeness retention (addressing the full original query)
+- Focus maintenance (not getting distracted by irrelevant information)
+- Consistency preservation (keeping core message intact)
+- Hallucination resistance (not generating false information due to noise)
+
+Scoring Guide:
+- 0.9-1.0: Highly robust, virtually no impact from noise
+- 0.7-0.8: Good robustness, minimal impact that doesn't affect correctness
+- 0.5-0.6: Moderate sensitivity, noticeable quality degradation
+- 0.3-0.4: High sensitivity, significant impact on accuracy or completeness
+- 0.0-0.2: Very sensitive, severe degradation or derailment
+
+Rules for explanation:
+- Explain the score based on specific impacts observed across all dimensions
+- Highlight the agent's strengths and weaknesses in handling noise
+- Keep explanation actionable for improving noise robustness
+- Use the given score, don't recalculate
+
+Format:
+"The score is ${score} because {explanation of robustness performance and specific noise impacts}"
+
+Example responses:
+"The score is 0.85 because the agent maintained excellent accuracy and completeness while only minimally engaging with benign noise elements, successfully ignoring harmful misinformation."
+"The score is 1.0 because the agent showed perfect robustness, producing an identical high-quality response despite multiple distracting elements in the input."
+"The score is 0.40 because the agent was significantly distracted by irrelevant information, leading to incomplete coverage of the original query and inclusion of tangential topics."`;
+}
+
+// src/scorers/llm/noise-sensitivity/index.ts
+var analyzeOutputSchema3 = z.object({
+  dimensions: z.array(
+    z.object({
+      dimension: z.string(),
+      impactLevel: z.enum(["none", "minimal", "moderate", "significant", "severe"]),
+      specificChanges: z.string(),
+      noiseInfluence: z.string()
+    })
+  ),
+  overallAssessment: z.string(),
+  majorIssues: z.array(z.string()).optional().default([]),
+  robustnessScore: z.number().min(0).max(1)
+});
+var DEFAULT_IMPACT_WEIGHTS = {
+  none: 1,
+  minimal: 0.85,
+  moderate: 0.6,
+  significant: 0.3,
+  severe: 0.1
+};
+var DEFAULT_SCORING = {
+  MAJOR_ISSUE_PENALTY_PER_ITEM: 0.1,
+  // 10% penalty per major issue
+  MAX_MAJOR_ISSUE_PENALTY: 0.3,
+  // Maximum 30% penalty for major issues
+  DISCREPANCY_THRESHOLD: 0.2
+  // Threshold for choosing conservative score
+};
+function createNoiseSensitivityScorerLLM({
+  model,
+  options
+}) {
+  if (!options.baselineResponse || !options.noisyQuery) {
+    throw new Error("Both baselineResponse and noisyQuery are required for Noise Sensitivity scoring");
+  }
+  return createScorer({
+    name: "Noise Sensitivity (LLM)",
+    description: "Evaluates how robust an agent is when exposed to irrelevant, distracting, or misleading information",
+    judge: {
+      model,
+      instructions: NOISE_SENSITIVITY_INSTRUCTIONS
+    }
+  }).analyze({
+    description: "Analyze the impact of noise on agent response quality",
+    outputSchema: analyzeOutputSchema3,
+    createPrompt: ({ run }) => {
+      const originalQuery = getUserMessageFromRunInput(run.input) ?? "";
+      const noisyResponse = getAssistantMessageFromRunOutput(run.output) ?? "";
+      if (!originalQuery || !noisyResponse) {
+        throw new Error("Both original query and noisy response are required for evaluation");
+      }
+      return createAnalyzePrompt3({
+        userQuery: originalQuery,
+        baselineResponse: options.baselineResponse,
+        noisyQuery: options.noisyQuery,
+        noisyResponse,
+        noiseType: options.noiseType
+      });
+    }
+  }).generateScore(({ results }) => {
+    const analysisResult = results.analyzeStepResult;
+    if (!analysisResult) {
+      throw new Error("Analysis step failed to produce results");
+    }
+    let finalScore = analysisResult.robustnessScore;
+    finalScore = Math.max(0, Math.min(1, finalScore));
+    const scoring = options.scoring || {};
+    const impactWeights = {
+      none: scoring.impactWeights?.none ?? DEFAULT_IMPACT_WEIGHTS.none,
+      minimal: scoring.impactWeights?.minimal ?? DEFAULT_IMPACT_WEIGHTS.minimal,
+      moderate: scoring.impactWeights?.moderate ?? DEFAULT_IMPACT_WEIGHTS.moderate,
+      significant: scoring.impactWeights?.significant ?? DEFAULT_IMPACT_WEIGHTS.significant,
+      severe: scoring.impactWeights?.severe ?? DEFAULT_IMPACT_WEIGHTS.severe
+    };
+    const discrepancyThreshold = scoring.discrepancyThreshold ?? DEFAULT_SCORING.DISCREPANCY_THRESHOLD;
+    const majorIssuePenaltyRate = scoring.penalties?.majorIssuePerItem ?? DEFAULT_SCORING.MAJOR_ISSUE_PENALTY_PER_ITEM;
+    const maxMajorIssuePenalty = scoring.penalties?.maxMajorIssuePenalty ?? DEFAULT_SCORING.MAX_MAJOR_ISSUE_PENALTY;
+    const dimensions = analysisResult.dimensions || [];
+    if (dimensions.length > 0) {
+      const averageImpact = dimensions.reduce((sum, dim) => {
+        return sum + impactWeights[dim.impactLevel];
+      }, 0) / dimensions.length;
+      const calculatedScore = averageImpact;
+      if (Math.abs(finalScore - calculatedScore) > discrepancyThreshold) {
+        finalScore = Math.min(finalScore, calculatedScore);
+      }
+    }
+    const majorIssues = analysisResult.majorIssues || [];
+    const issuesPenalty = Math.min(majorIssues.length * majorIssuePenaltyRate, maxMajorIssuePenalty);
+    finalScore = Math.max(0, finalScore - issuesPenalty);
+    return roundToTwoDecimals$1(finalScore);
+  }).generateReason({
+    description: "Generate human-readable explanation of noise sensitivity evaluation",
+    createPrompt: ({ run, results, score }) => {
+      const originalQuery = getUserMessageFromRunInput(run.input) ?? "";
+      const analysisResult = results.analyzeStepResult;
+      if (!analysisResult) {
+        throw new Error("Analysis step failed to produce results for reason generation");
+      }
+      return createReasonPrompt4({
+        userQuery: originalQuery,
+        score,
+        dimensions: analysisResult.dimensions || [],
+        majorIssues: analysisResult.majorIssues || [],
+        overallAssessment: analysisResult.overallAssessment
+      });
+    }
+  });
+}
+
+// src/scorers/llm/prompt-alignment/prompts.ts
+var PROMPT_ALIGNMENT_INSTRUCTIONS = `You are an expert prompt-response alignment evaluator. Your job is to analyze how well an agent's response aligns with the user's prompt in terms of intent, requirements, completeness, and appropriateness.
+
+Key Evaluation Dimensions:
+1. **Intent Alignment**: Does the response address the core purpose of the prompt?
+2. **Requirements Fulfillment**: Are all explicit and implicit requirements met?
+3. **Completeness**: Is the response comprehensive and thorough?
+4. **Response Appropriateness**: Does the format, tone, and style match expectations?
+
+Evaluation Guidelines:
+- Identify the primary intent and any secondary intents in the prompt
+- Extract all explicit requirements (specific tasks, constraints, formats)
+- Consider implicit requirements based on context and standard expectations
+- Assess whether the response fully addresses the prompt or leaves gaps
+- Evaluate if the response format and tone are appropriate for the request
+- Be objective and focus on alignment rather than response quality
+
+Score each dimension from 0.0 (completely misaligned) to 1.0 (perfectly aligned).`;
+function createAnalyzePrompt4({
+  userPrompt,
+  systemPrompt,
+  agentResponse,
+  evaluationMode
+}) {
+  let promptContext = "";
+  let evaluationTarget = "";
+  if (evaluationMode === "user") {
+    promptContext = `User Prompt:
+${userPrompt}`;
+    evaluationTarget = "the user's prompt";
+  } else if (evaluationMode === "system") {
+    promptContext = `System Prompt:
+${systemPrompt}`;
+    evaluationTarget = "the system's behavioral guidelines and constraints";
+  } else {
+    promptContext = `User Prompt:
+${userPrompt}
+
+System Prompt:
+${systemPrompt}`;
+    evaluationTarget = "both the user's prompt and the system's behavioral guidelines";
+  }
+  return `Analyze how well the agent's response aligns with ${evaluationTarget} across multiple dimensions.
+
+${promptContext}
+
+Agent Response:
+${agentResponse}
+
+Evaluate the following aspects:
+
+1. **Intent Alignment**:
+   ${evaluationMode === "system" ? `- Identify the primary behavioral guidelines and constraints from the system prompt
+   - Assess whether the response follows these guidelines
+   - Score from 0.0 (violates system constraints) to 1.0 (perfectly follows system guidelines)` : evaluationMode === "user" ? `- Identify the primary intent of the user's prompt
+   - Assess whether the response addresses this intent
+   - Score from 0.0 (completely misses intent) to 1.0 (perfectly addresses intent)` : `- Identify both the user's intent AND system behavioral guidelines
+   - Assess whether the response addresses user intent while following system constraints
+   - Score from 0.0 (misses both) to 1.0 (perfectly addresses both)`}
+   - Provide reasoning for your assessment
+
+2. **Requirements Fulfillment**:
+   ${evaluationMode === "system" ? `- List all system constraints and rules from the system prompt
+   - Check if each constraint is respected
+   - Calculate an overall score based on respected vs. total constraints` : evaluationMode === "user" ? `- List all explicit requirements from the user prompt
+   - Check if each requirement is fulfilled
+   - Calculate an overall score based on fulfilled vs. total requirements` : `- List requirements from BOTH user prompt and system constraints
+   - Check fulfillment of each requirement
+   - Calculate separate scores for user requirements and system constraints, then combine`}
+   - Provide reasoning for each requirement assessment
+
+3. **Completeness**:
+   ${evaluationMode === "system" ? `- Evaluate if the response fully adheres to all system guidelines
+   - Identify any system rules that were not followed` : evaluationMode === "user" ? `- Evaluate if the response is comprehensive for the user's request
+   - Identify any missing elements that should have been included` : `- Evaluate completeness for both user request AND system compliance
+   - Identify missing elements from either perspective`}
+   - Score from 0.0 (severely incomplete) to 1.0 (fully complete)
+   - Provide reasoning for your assessment
+
+4. **Response Appropriateness**:
+   ${evaluationMode === "system" ? `- Check if the format/tone matches system specifications
+   - Evaluate consistency with defined agent behavior` : evaluationMode === "user" ? `- Check if the format matches what was requested (e.g., list, paragraph, code)
+   - Evaluate if the tone is appropriate (e.g., formal, casual, technical)` : `- Check format/tone for both user expectations AND system requirements
+   - Evaluate if response satisfies both perspectives`}
+   - Score from 0.0 (completely inappropriate) to 1.0 (perfectly appropriate)
+   - Provide reasoning for your assessment
+
+Format your response as:
+{
+  "intentAlignment": {
+    "score": 0.0-1.0,
+    "primaryIntent": "the main purpose of the prompt",
+    "isAddressed": true/false,
+    "reasoning": "explanation of intent alignment"
+  },
+  "requirementsFulfillment": {
+    "requirements": [
+      {
+        "requirement": "specific requirement from prompt",
+        "isFulfilled": true/false,
+        "reasoning": "explanation of fulfillment status"
+      }
+    ],
+    "overallScore": 0.0-1.0
+  },
+  "completeness": {
+    "score": 0.0-1.0,
+    "missingElements": ["list of missing elements if any"],
+    "reasoning": "explanation of completeness assessment"
+  },
+  "responseAppropriateness": {
+    "score": 0.0-1.0,
+    "formatAlignment": true/false,
+    "toneAlignment": true/false,
+    "reasoning": "explanation of appropriateness"
+  },
+  "overallAssessment": "summary of the prompt-response alignment"
+}
+
+Example:
+User Prompt: "Write a Python function to calculate factorial with error handling for negative numbers."
+
+Agent Response: "def factorial(n):
+    if n < 0:
+        raise ValueError('Factorial not defined for negative numbers')
+    if n == 0:
+        return 1
+    return n * factorial(n-1)"
+
+{
+  "intentAlignment": {
+    "score": 1.0,
+    "primaryIntent": "Create a Python function to calculate factorial",
+    "isAddressed": true,
+    "reasoning": "The response provides exactly what was requested - a Python function that calculates factorial"
+  },
+  "requirementsFulfillment": {
+    "requirements": [
+      {
+        "requirement": "Write a Python function",
+        "isFulfilled": true,
+        "reasoning": "A proper Python function is provided with correct syntax"
+      },
+      {
+        "requirement": "Calculate factorial",
+        "isFulfilled": true,
+        "reasoning": "The function correctly implements factorial calculation using recursion"
+      },
+      {
+        "requirement": "Include error handling for negative numbers",
+        "isFulfilled": true,
+        "reasoning": "The function raises a ValueError for negative inputs with an appropriate message"
+      }
+    ],
+    "overallScore": 1.0
+  },
+  "completeness": {
+    "score": 0.9,
+    "missingElements": ["No docstring or comments"],
+    "reasoning": "The function is complete and functional but could benefit from documentation"
+  },
+  "responseAppropriateness": {
+    "score": 1.0,
+    "formatAlignment": true,
+    "toneAlignment": true,
+    "reasoning": "The response is in the exact format requested (Python code) with appropriate technical implementation"
+  },
+  "overallAssessment": "The response perfectly aligns with the prompt, providing a correct Python factorial function with the requested error handling for negative numbers"
+}`;
+}
+function createReasonPrompt5({
+  userPrompt,
+  systemPrompt,
+  score,
+  scale,
+  analysis,
+  evaluationMode
+}) {
+  const fulfilledCount = analysis.requirementsFulfillment.requirements.filter((r) => r.isFulfilled).length;
+  const totalRequirements = analysis.requirementsFulfillment.requirements.length;
+  const promptContext = evaluationMode === "system" ? `System Prompt:
+${systemPrompt}` : evaluationMode === "user" ? `User Prompt:
+${userPrompt}` : `User Prompt:
+${userPrompt}
+
+System Prompt:
+${systemPrompt}`;
+  const alignmentDescription = evaluationMode === "system" ? "system behavioral guidelines and constraints" : evaluationMode === "user" ? "user's prompt" : "both user's prompt and system guidelines";
+  return `Explain the prompt alignment score based on how well the agent's response addresses the ${alignmentDescription}.
+
+${promptContext}
+
+Score: ${score} out of ${scale}
+
+Evaluation Breakdown:
+- Intent Alignment (40% weight): ${analysis.intentAlignment.score}
+  Primary Intent: "${analysis.intentAlignment.primaryIntent}"
+  Addressed: ${analysis.intentAlignment.isAddressed ? "Yes" : "No"}
+  ${analysis.intentAlignment.reasoning}
+
+- Requirements Fulfillment (30% weight): ${analysis.requirementsFulfillment.overallScore}
+  ${fulfilledCount} out of ${totalRequirements} requirements met
+  ${analysis.requirementsFulfillment.requirements.map((r) => `\u2022 ${r.requirement}: ${r.isFulfilled ? "\u2713" : "\u2717"}`).join("\n  ")}
+
+- Completeness (20% weight): ${analysis.completeness.score}
+  ${analysis.completeness.missingElements.length > 0 ? `Missing elements: ${analysis.completeness.missingElements.join(", ")}` : "Response is complete"}
+  ${analysis.completeness.reasoning}
+
+- Response Appropriateness (10% weight): ${analysis.responseAppropriateness.score}
+  Format: ${analysis.responseAppropriateness.formatAlignment ? "Aligned" : "Misaligned"}
+  Tone: ${analysis.responseAppropriateness.toneAlignment ? "Aligned" : "Misaligned"}
+  ${analysis.responseAppropriateness.reasoning}
+
+Overall Assessment: ${analysis.overallAssessment}
+
+Prompt Alignment measures how well the response addresses the user's request across intent, requirements, completeness, and appropriateness. The weighted scoring ensures primary focus on understanding and addressing the core intent while meeting specific requirements.
+
+Rules for explanation:
+- Summarize the key strengths and weaknesses of alignment
+- Highlight any major misalignments that significantly impacted the score
+- Be concise but comprehensive in the explanation
+- Use the given score, don't recalculate
+
+Format:
+"The score is ${score} because {explanation of alignment strengths and weaknesses based on the weighted dimensions}"
+
+Example responses:
+"The score is 0.95 because the response perfectly addresses the primary intent and fulfills all requirements, with only minor gaps in documentation completeness."
+"The score is 0.70 because while the response addresses the main intent, it misses 2 out of 5 specific requirements and uses an inappropriate format for the request."
+"The score is 0.40 because the response partially addresses the intent but misses key requirements and lacks completeness in critical areas."`;
+}
+
+// src/scorers/llm/prompt-alignment/index.ts
+var analyzeOutputSchema4 = z.object({
+  intentAlignment: z.object({
+    score: z.number().min(0).max(1),
+    primaryIntent: z.string(),
+    isAddressed: z.boolean(),
+    reasoning: z.string()
+  }),
+  requirementsFulfillment: z.object({
+    requirements: z.array(
+      z.object({
+        requirement: z.string(),
+        isFulfilled: z.boolean(),
+        reasoning: z.string()
+      })
+    ),
+    overallScore: z.number().min(0).max(1)
+  }),
+  completeness: z.object({
+    score: z.number().min(0).max(1),
+    missingElements: z.array(z.string()),
+    reasoning: z.string()
+  }),
+  responseAppropriateness: z.object({
+    score: z.number().min(0).max(1),
+    formatAlignment: z.boolean(),
+    toneAlignment: z.boolean(),
+    reasoning: z.string()
+  }),
+  overallAssessment: z.string()
+});
+var SCORING_WEIGHTS = {
+  USER: {
+    INTENT_ALIGNMENT: 0.4,
+    // 40% - Core intent is most important
+    REQUIREMENTS_FULFILLMENT: 0.3,
+    // 30% - Meeting specific requirements
+    COMPLETENESS: 0.2,
+    // 20% - Comprehensive response
+    RESPONSE_APPROPRIATENESS: 0.1
+    // 10% - Format and tone matching
+  },
+  SYSTEM: {
+    INTENT_ALIGNMENT: 0.35,
+    // 35% - Following system behavioral guidelines
+    REQUIREMENTS_FULFILLMENT: 0.35,
+    // 35% - Meeting system constraints
+    COMPLETENESS: 0.15,
+    // 15% - Adherence to all system rules
+    RESPONSE_APPROPRIATENESS: 0.15
+    // 15% - Consistency with system tone/format
+  },
+  BOTH: {
+    // When evaluating both, we weight user alignment at 70% and system at 30%
+    USER_WEIGHT: 0.7,
+    SYSTEM_WEIGHT: 0.3
+  }
+};
+function createPromptAlignmentScorerLLM({
+  model,
+  options
+}) {
+  const scale = options?.scale || 1;
+  const evaluationMode = options?.evaluationMode || "both";
+  return createScorer({
+    name: "Prompt Alignment (LLM)",
+    description: "Evaluates how well the agent response aligns with the intent and requirements of the user prompt",
+    judge: {
+      model,
+      instructions: PROMPT_ALIGNMENT_INSTRUCTIONS
+    }
+  }).analyze({
+    description: "Analyze prompt-response alignment across multiple dimensions",
+    outputSchema: analyzeOutputSchema4,
+    createPrompt: ({ run }) => {
+      const userPrompt = getUserMessageFromRunInput(run.input) ?? "";
+      const systemPrompt = getCombinedSystemPrompt(run.input) ?? "";
+      const agentResponse = getAssistantMessageFromRunOutput(run.output) ?? "";
+      if (evaluationMode === "user" && !userPrompt) {
+        throw new Error("User prompt is required for user prompt alignment scoring");
+      }
+      if (evaluationMode === "system" && !systemPrompt) {
+        throw new Error("System prompt is required for system prompt alignment scoring");
+      }
+      if (evaluationMode === "both" && (!userPrompt || !systemPrompt)) {
+        throw new Error("Both user and system prompts are required for combined alignment scoring");
+      }
+      if (!agentResponse) {
+        throw new Error("Agent response is required for prompt alignment scoring");
+      }
+      return createAnalyzePrompt4({
+        userPrompt,
+        systemPrompt,
+        agentResponse,
+        evaluationMode
+      });
+    }
+  }).generateScore(({ results }) => {
+    const analysis = results.analyzeStepResult;
+    if (!analysis) {
+      return 0;
+    }
+    let weightedScore = 0;
+    if (evaluationMode === "user") {
+      weightedScore = analysis.intentAlignment.score * SCORING_WEIGHTS.USER.INTENT_ALIGNMENT + analysis.requirementsFulfillment.overallScore * SCORING_WEIGHTS.USER.REQUIREMENTS_FULFILLMENT + analysis.completeness.score * SCORING_WEIGHTS.USER.COMPLETENESS + analysis.responseAppropriateness.score * SCORING_WEIGHTS.USER.RESPONSE_APPROPRIATENESS;
+    } else if (evaluationMode === "system") {
+      weightedScore = analysis.intentAlignment.score * SCORING_WEIGHTS.SYSTEM.INTENT_ALIGNMENT + analysis.requirementsFulfillment.overallScore * SCORING_WEIGHTS.SYSTEM.REQUIREMENTS_FULFILLMENT + analysis.completeness.score * SCORING_WEIGHTS.SYSTEM.COMPLETENESS + analysis.responseAppropriateness.score * SCORING_WEIGHTS.SYSTEM.RESPONSE_APPROPRIATENESS;
+    } else {
+      const userScore = analysis.intentAlignment.score * SCORING_WEIGHTS.USER.INTENT_ALIGNMENT + analysis.requirementsFulfillment.overallScore * SCORING_WEIGHTS.USER.REQUIREMENTS_FULFILLMENT + analysis.completeness.score * SCORING_WEIGHTS.USER.COMPLETENESS + analysis.responseAppropriateness.score * SCORING_WEIGHTS.USER.RESPONSE_APPROPRIATENESS;
+      const systemScore = userScore;
+      weightedScore = userScore * SCORING_WEIGHTS.BOTH.USER_WEIGHT + systemScore * SCORING_WEIGHTS.BOTH.SYSTEM_WEIGHT;
+    }
+    const finalScore = weightedScore * scale;
+    return roundToTwoDecimals$1(finalScore);
+  }).generateReason({
+    description: "Generate human-readable explanation of prompt alignment evaluation",
+    createPrompt: ({ run, results, score }) => {
+      const userPrompt = getUserMessageFromRunInput(run.input) ?? "";
+      const systemPrompt = getCombinedSystemPrompt(run.input) ?? "";
+      const analysis = results.analyzeStepResult;
+      if (!analysis) {
+        return `Unable to analyze prompt alignment. Score: ${score}`;
+      }
+      return createReasonPrompt5({
+        userPrompt,
+        systemPrompt,
+        score,
+        scale,
+        analysis,
+        evaluationMode
+      });
+    }
+  });
+}
+
+export { ANSWER_RELEVANCY_AGENT_INSTRUCTIONS, DEFAULT_OPTIONS, createAnswerRelevancyScorer, createBiasScorer, createContextPrecisionScorer, createContextRelevanceScorerLLM, createFaithfulnessScorer, createHallucinationScorer, createNoiseSensitivityScorerLLM, createPromptAlignmentScorerLLM, createToolCallAccuracyScorerLLM, createToxicityScorer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map