@juspay/neurolink 9.54.5 → 9.54.7

package/dist/lib/evaluation/EvaluationAggregator.d.ts

@@ -2,123 +2,7 @@
  * @file EvaluationAggregator - Aggregates and analyzes evaluation results.
  * Provides statistical analysis, trend detection, and summary generation.
  */
-import type { EvaluationData } from "../types/index.js";
-/**
- * Statistical summary of evaluation scores.
- */
-type ScoreStatistics = {
-    /** Minimum score */
-    min: number;
-    /** Maximum score */
-    max: number;
-    /** Mean (average) score */
-    mean: number;
-    /** Median score */
-    median: number;
-    /** Standard deviation */
-    stdDev: number;
-    /** Variance */
-    variance: number;
-    /** 25th percentile */
-    p25: number;
-    /** 75th percentile */
-    p75: number;
-    /** 90th percentile */
-    p90: number;
-    /** 95th percentile */
-    p95: number;
-};
-/**
- * Score distribution across ranges.
- */
-type ScoreDistribution = {
-    /** Items scoring 1-3 (poor) */
-    poor: number;
-    /** Items scoring 4-5 (below average) */
-    belowAverage: number;
-    /** Items scoring 6-7 (average) */
-    average: number;
-    /** Items scoring 8-9 (good) */
-    good: number;
-    /** Items scoring 10 (excellent) */
-    excellent: number;
-};
-/**
- * Trend analysis results.
- */
-type TrendAnalysis = {
-    /** Direction of the trend */
-    direction: "improving" | "declining" | "stable";
-    /** Slope of the linear regression */
-    slope: number;
-    /** R-squared value (fit quality) */
-    rSquared: number;
-    /** Percentage change from first to last */
-    percentChange: number;
-    /** Moving average of last N evaluations */
-    movingAverage: number;
-};
-/**
- * Dimension-specific analysis for RAGAS metrics.
- */
-type DimensionAnalysis = {
-    /** Relevance score statistics */
-    relevance: ScoreStatistics;
-    /** Accuracy score statistics */
-    accuracy: ScoreStatistics;
-    /** Completeness score statistics */
-    completeness: ScoreStatistics;
-    /** Overall score statistics */
-    overall: ScoreStatistics;
-    /** Correlation matrix between dimensions */
-    correlations: {
-        relevanceAccuracy: number;
-        relevanceCompleteness: number;
-        accuracyCompleteness: number;
-    };
-};
-/**
- * Quality alerts summary.
- */
-type AlertSummary = {
-    /** Total number of alerts */
-    total: number;
-    /** Number of high severity alerts */
-    high: number;
-    /** Number of medium severity alerts */
-    medium: number;
-    /** Number of items marked as off-topic */
-    offTopic: number;
-    /** Alert rate as percentage */
-    alertRate: number;
-};
-/**
- * Comprehensive aggregation result.
- */
-type AggregationResult = {
-    /** Number of evaluations aggregated */
-    count: number;
-    /** Statistics for overall scores */
-    statistics: ScoreStatistics;
-    /** Score distribution */
-    distribution: ScoreDistribution;
-    /** Dimension-specific analysis */
-    dimensions: DimensionAnalysis;
-    /** Sequence trend analysis based on insertion order (not time-based) */
-    sequenceTrend?: TrendAnalysis;
-    /** Alert summary */
-    alerts: AlertSummary;
-    /** Passing rate based on threshold */
-    passingRate: number;
-    /** Average evaluation time */
-    avgEvaluationTime: number;
-    /** Aggregation metadata */
-    metadata: {
-        aggregatedAt: string;
-        threshold: number;
-        evaluationModels: string[];
-    };
-};
+import type { AggregationResult, EvaluationData, ScoreDistribution, ScoreStatistics, TrendAnalysis } from "../types/index.js";
 /**
  * EvaluationAggregator - Aggregates evaluation results and provides analytics.
  * Supports statistical analysis, trend detection, and quality monitoring.
@@ -270,4 +154,3 @@ export declare class EvaluationAggregator {
      */
     generateSummary(threshold?: number): string;
 }
-export {};

package/dist/lib/evaluation/EvaluatorFactory.d.ts

@@ -3,19 +3,8 @@
  * Extends BaseFactory to provide dynamic evaluator creation with configuration support.
  */
 import { BaseFactory } from "../core/infrastructure/index.js";
-import type { EvaluationConfig } from "../types/index.js";
+import type { EvaluationConfig, EvaluatorPreset } from "../types/index.js";
 import { Evaluator } from "./index.js";
-/**
- * Configuration presets for common evaluation scenarios.
- */
-type EvaluatorPreset = {
-    /** Preset name for identification */
-    name: string;
-    /** Description of the preset use case */
-    description: string;
-    /** The underlying evaluation configuration (optional for built-in presets) */
-    config?: EvaluationConfig;
-};
 /**
  * Factory for creating Evaluator instances with various configurations.
  * Supports presets for common use cases and custom configurations.
@@ -111,4 +100,3 @@ export declare class EvaluatorFactory extends BaseFactory<Evaluator, EvaluationC
     unregisterPreset(name: string): boolean;
 }
 export declare const getEvaluatorFactory: () => EvaluatorFactory;
-export {};

package/dist/lib/evaluation/EvaluatorRegistry.d.ts

@@ -3,55 +3,7 @@
  * Extends BaseRegistry to provide dynamic strategy registration and lookup.
  */
 import { BaseRegistry } from "../core/infrastructure/index.js";
-import type { LanguageModelV3CallOptions } from "@ai-sdk/provider";
-import type { GenerateResult, EvaluationResult, EnhancedEvaluationContext } from "../types/index.js";
-/**
- * A function that performs evaluation and returns results.
- */
-type EvaluationStrategyFunction = (options: LanguageModelV3CallOptions, result: GenerateResult, config?: EvaluationStrategyConfig) => Promise<{
-    evaluationResult: EvaluationResult;
-    evalContext: EnhancedEvaluationContext;
-}>;
-/**
- * Configuration for evaluation strategies.
- */
-type EvaluationStrategyConfig = {
-    /** The model to use for evaluation */
-    evaluationModel?: string;
-    /** The provider to use for evaluation */
-    provider?: string;
-    /** The passing threshold (1-10) */
-    threshold?: number;
-    /** Custom prompt generator */
-    promptGenerator?: (context: {
-        userQuery: string;
-        history: string;
-        tools: string;
-        retryInfo: string;
-        aiResponse: string;
-    }) => string;
-    /** Additional strategy-specific options */
-    options?: Record<string, unknown>;
-};
-/**
- * Metadata for registered evaluation strategies.
- */
-type EvaluationStrategyMetadata = {
-    /** Human-readable name for the strategy */
-    name: string;
-    /** Description of what the strategy does */
-    description: string;
-    /** Whether the strategy requires an external LLM */
-    requiresLLM: boolean;
-    /** Default model for the strategy (if requiresLLM is true) */
-    defaultModel?: string;
-    /** Default provider for the strategy (if requiresLLM is true) */
-    defaultProvider?: string;
-    /** Version of the strategy */
-    version: string;
-    /** Supported features */
-    features: string[];
-};
+import type { EvaluationStrategyFunction, EvaluationStrategyMetadata } from "../types/index.js";
 /**
  * Registry for evaluation strategies.
  * Allows dynamic registration and retrieval of evaluation strategies.
@@ -157,4 +109,3 @@ export declare class EvaluatorRegistry extends BaseRegistry<EvaluationStrategyFu
     getStrategiesByProvider(provider: string): Promise<string[]>;
 }
 export declare const getEvaluatorRegistry: () => EvaluatorRegistry;
-export {};

package/dist/lib/evaluation/errors/EvaluationError.d.ts

@@ -3,7 +3,7 @@
  * Uses NeuroLinkFeatureError and createErrorFactory from core infrastructure.
  */
 import { NeuroLinkFeatureError } from "../../core/infrastructure/index.js";
-import type { EnhancedEvaluationContext } from "../../types/index.js";
+import type { EnhancedEvaluationContext, EvaluationErrorContext } from "../../types/index.js";
 /**
  * Error codes for the Evaluation feature.
  * These codes help identify specific error scenarios for proper handling.
@@ -65,36 +65,12 @@ export declare const evaluationErrors: {
         /** Rate limit hit during evaluation */
         readonly RATE_LIMIT_ERROR: "RATE_LIMIT_ERROR";
     };
-    create: (code: "PROVIDER_ERROR" | "CONFIGURATION_ERROR" | "EVALUATION_FAILED" | "PARSE_ERROR" | "STRATEGY_NOT_FOUND" | "CUSTOM_EVALUATOR_ERROR" | "BATCH_EVALUATION_ERROR" | "AGGREGATION_ERROR" | "REGISTRY_ERROR" | "MAX_RETRIES_EXCEEDED" | "TIMEOUT_ERROR" | "RATE_LIMIT_ERROR", message: string, options?: {
+    create: (code: "CONFIGURATION_ERROR" | "PROVIDER_ERROR" | "EVALUATION_FAILED" | "PARSE_ERROR" | "STRATEGY_NOT_FOUND" | "CUSTOM_EVALUATOR_ERROR" | "BATCH_EVALUATION_ERROR" | "AGGREGATION_ERROR" | "REGISTRY_ERROR" | "MAX_RETRIES_EXCEEDED" | "TIMEOUT_ERROR" | "RATE_LIMIT_ERROR", message: string, options?: {
         retryable?: boolean;
         details?: Record<string, unknown>;
         cause?: Error;
     } | undefined) => NeuroLinkFeatureError;
 };
-/**
- * Extended evaluation context for error details.
- * Provides rich debugging information when errors occur.
- */
-type EvaluationErrorContext = {
-    /** Length of the user query (redacted for safety) */
-    userQueryLength?: number;
-    /** Length of the AI response (redacted for safety) */
-    aiResponseLength?: number;
-    /** The current attempt number */
-    attemptNumber?: number;
-    /** Previous evaluation scores if any */
-    previousScores?: number[];
-    /** The evaluation strategy in use */
-    strategy?: string;
-    /** The evaluation model being used */
-    evaluationModel?: string;
-    /** The provider being used */
-    provider?: string;
-    /** Length of the raw response (redacted for safety) */
-    rawResponseLength?: number;
-    /** Any additional context */
-    additionalContext?: Record<string, unknown>;
-};
 /**
  * Checks if an error is retryable based on its code.
  * Transient errors (timeout, rate limit, some provider errors) are retryable.
@@ -183,4 +159,3 @@ export declare function createConfigurationError(message: string, configIssue: s
  * @returns An EvaluationErrorContext
  */
 export declare function contextToErrorContext(context: EnhancedEvaluationContext): EvaluationErrorContext;
-export {};

package/dist/lib/evaluation/hooks/langfuseAdapter.d.ts

@@ -2,44 +2,7 @@
  * @file Langfuse Adapter
  * Integration with Langfuse for LLM observability
  */
-/**
- * Langfuse client interface (minimal for type safety)
- */
-type LangfuseClient = {
-    score: (params: {
-        name: string;
-        value: number;
-        traceId?: string;
-        observationId?: string;
-        comment?: string;
-        metadata?: Record<string, unknown>;
-    }) => Promise<unknown>;
-    trace?: (params: {
-        name: string;
-        metadata?: Record<string, unknown>;
-        tags?: string[];
-    }) => {
-        id: string;
-    };
-    shutdown?: () => Promise<void>;
-};
-/**
- * Langfuse adapter configuration
- */
-type LangfuseAdapterConfig = {
-    /** Langfuse client instance */
-    client: LangfuseClient;
-    /** Prefix for score names */
-    scorePrefix?: string;
-    /** Include detailed metadata */
-    includeMetadata?: boolean;
-    /** Tags to add to all scores */
-    tags?: string[];
-    /** Whether to send pipeline-level scores */
-    sendPipelineScores?: boolean;
-    /** Whether to send individual scorer scores */
-    sendScorerScores?: boolean;
-};
+import type { LangfuseAdapterConfig, LangfuseClient } from "../../types/index.js";
 /**
  * Langfuse adapter for evaluation observability
  */
@@ -97,4 +60,3 @@ export declare function createMockLangfuseClient(): LangfuseClient & {
         metadata?: Record<string, unknown>;
     }>;
 };
-export {};

package/dist/lib/evaluation/hooks/observabilityHooks.d.ts

@@ -2,57 +2,7 @@
  * @file Observability Hooks
  * OpenTelemetry integration for evaluation tracing
  */
-import type { EvaluationTraceContext, ScoreResult, PipelineResult } from "../../types/index.js";
-/**
- * Event handler type
- */
-type EventHandler<T> = (event: T) => void | Promise<void>;
-/**
- * Evaluation events
- */
-type EvaluationEvents = {
-    "scorer:start": {
-        scorerId: string;
-        scorerName: string;
-        timestamp: number;
-        traceContext?: EvaluationTraceContext;
-    };
-    "scorer:end": {
-        scorerId: string;
-        scorerName: string;
-        result: ScoreResult;
-        timestamp: number;
-        duration: number;
-        traceContext?: EvaluationTraceContext;
-    };
-    "scorer:error": {
-        scorerId: string;
-        scorerName: string;
-        error: string;
-        timestamp: number;
-        traceContext?: EvaluationTraceContext;
-    };
-    "pipeline:start": {
-        pipelineName: string;
-        scorerCount: number;
-        timestamp: number;
-        correlationId: string;
-        traceContext?: EvaluationTraceContext;
-    };
-    "pipeline:end": {
-        pipelineName: string;
-        result: PipelineResult;
-        timestamp: number;
-        duration: number;
-        traceContext?: EvaluationTraceContext;
-    };
-    "pipeline:error": {
-        pipelineName: string;
-        error: string;
-        timestamp: number;
-        traceContext?: EvaluationTraceContext;
-    };
-};
+import type { EvaluationEvents, EvaluationSpanAttributes, EvaluationTraceContext, EventHandler, PipelineResult, ScoreResult } from "../../types/index.js";
 /**
  * Observability hooks manager
  */
@@ -117,13 +67,11 @@ export declare function createMetricsCollectorHook(collector: {
 /**
  * OpenTelemetry span attributes
  */
-type SpanAttributes = Record<string, string | number | boolean>;
 /**
  * Create span attributes from scorer result
  */
-export declare function scorerToSpanAttributes(result: ScoreResult): SpanAttributes;
+export declare function scorerToSpanAttributes(result: ScoreResult): EvaluationSpanAttributes;
 /**
  * Create span attributes from pipeline result
  */
-export declare function pipelineToSpanAttributes(result: PipelineResult): SpanAttributes;
-export {};
+export declare function pipelineToSpanAttributes(result: PipelineResult): EvaluationSpanAttributes;

package/dist/lib/evaluation/hooks/observabilityHooks.js

@@ -145,6 +145,9 @@ export function createMetricsCollectorHook(collector) {
         collector.recordPipeline(event.result);
     });
 }
+/**
+ * OpenTelemetry span attributes
+ */
 /**
  * Create span attributes from scorer result
  */

package/dist/lib/evaluation/pipeline/strategies/batchStrategy.d.ts

@@ -2,72 +2,19 @@
  * @file Batch Strategy
  * Batch processing for evaluation pipelines
  */
-import type { ScorerInput, PipelineExecutionOptions, PipelineResult } from "../../../types/index.js";
+import type { ScorerInput, PipelineExecutionOptions, BatchEvaluationConfig, BatchEvaluationResult, BatchItemResult } from "../../../types/index.js";
 import type { EvaluationPipeline } from "../evaluationPipeline.js";
-/**
- * Batch processing configuration
- */
-type BatchConfig = {
-    /** Maximum concurrent evaluations */
-    concurrency?: number;
-    /** Delay between batches (ms) */
-    batchDelay?: number;
-    /** Continue on individual failures */
-    continueOnError?: boolean;
-    /** Progress callback */
-    onProgress?: (progress: BatchProgress) => void;
-    /** Individual result callback */
-    onResult?: (result: BatchItemResult) => void;
-};
-/**
- * Batch progress information
- */
-type BatchProgress = {
-    total: number;
-    completed: number;
-    failed: number;
-    remaining: number;
-    percentComplete: number;
-    estimatedTimeRemaining?: number;
-};
-/**
- * Individual batch item result
- */
-type BatchItemResult = {
-    index: number;
-    input: ScorerInput;
-    result?: PipelineResult;
-    error?: string;
-    duration: number;
-};
-/**
- * Batch evaluation result
- */
-type BatchResult = {
-    /** All individual results */
-    results: BatchItemResult[];
-    /** Summary statistics */
-    summary: {
-        total: number;
-        successful: number;
-        failed: number;
-        averageScore: number;
-        passRate: number;
-        totalDuration: number;
-        averageDuration: number;
-    };
-};
 /**
  * Batch evaluation strategy
  */
 export declare class BatchStrategy {
     private _pipeline;
     private _config;
-    constructor(pipeline: EvaluationPipeline, config?: BatchConfig);
+    constructor(pipeline: EvaluationPipeline, config?: BatchEvaluationConfig);
     /**
      * Evaluate a batch of inputs
      */
-    evaluate(inputs: ScorerInput[], options?: PipelineExecutionOptions): Promise<BatchResult>;
+    evaluate(inputs: ScorerInput[], options?: PipelineExecutionOptions): Promise<BatchEvaluationResult>;
     /**
      * Evaluate a single item
      */
@@ -83,18 +30,17 @@ export declare class BatchStrategy {
     /**
      * Update configuration
      */
-    configure(config: Partial<BatchConfig>): void;
+    configure(config: Partial<BatchEvaluationConfig>): void;
 }
 /**
  * Create a batch strategy for a pipeline
  */
-export declare function createBatchStrategy(pipeline: EvaluationPipeline, config?: BatchConfig): BatchStrategy;
+export declare function createBatchStrategy(pipeline: EvaluationPipeline, config?: BatchEvaluationConfig): BatchStrategy;
 /**
  * Evaluate a batch of inputs using a pipeline
  */
-export declare function evaluateBatch(pipeline: EvaluationPipeline, inputs: ScorerInput[], config?: BatchConfig): Promise<BatchResult>;
+export declare function evaluateBatch(pipeline: EvaluationPipeline, inputs: ScorerInput[], config?: BatchEvaluationConfig): Promise<BatchEvaluationResult>;
 /**
  * Stream batch evaluation results
  */
-export declare function streamBatchEvaluation(pipeline: EvaluationPipeline, inputs: ScorerInput[], config?: Omit<BatchConfig, "onResult" | "onProgress">): AsyncGenerator<BatchItemResult, BatchResult["summary"], void>;
-export {};
+export declare function streamBatchEvaluation(pipeline: EvaluationPipeline, inputs: ScorerInput[], config?: Omit<BatchEvaluationConfig, "onResult" | "onProgress">): AsyncGenerator<BatchItemResult, BatchEvaluationResult["summary"], void>;

package/dist/lib/evaluation/pipeline/strategies/batchStrategy.js

@@ -57,7 +57,7 @@ export class BatchStrategy {
                 total: inputs.length,
                 completed: results.length,
                 failed: results.filter((r) => r.error).length,
-                remaining: inputs.length - results.length,
+                pending: inputs.length - results.length,
                 percentComplete: (results.length / inputs.length) * 100,
                 estimatedTimeRemaining: this._estimateRemainingTime(durations, inputs.length - results.length),
             });
@@ -76,12 +76,12 @@ export class BatchStrategy {
             results,
             summary: {
                 total: inputs.length,
-                successful: successfulResults.length,
+                succeeded: successfulResults.length,
                 failed: results.length - successfulResults.length,
                 averageScore: scores.length > 0
                     ? scores.reduce((a, b) => a + b, 0) / scores.length
                     : 0,
-                passRate: successfulResults.length > 0
+                passingRate: successfulResults.length > 0
                     ? passed.length / successfulResults.length
                     : 0,
                 totalDuration,
@@ -200,12 +200,12 @@ export async function* streamBatchEvaluation(pipeline, inputs, config) {
                 const earlyPassed = successfulResults.filter((r) => r.result.passed);
                 return {
                     total: inputs.length,
-                    successful: successfulResults.length,
+                    succeeded: successfulResults.length,
                     failed: results.length - successfulResults.length,
                     averageScore: earlyScores.length > 0
                         ? earlyScores.reduce((a, b) => a + b, 0) / earlyScores.length
                         : 0,
-                    passRate: successfulResults.length > 0
+                    passingRate: successfulResults.length > 0
                         ? earlyPassed.length / successfulResults.length
                         : 0,
                     totalDuration: Date.now() - startTime,
@@ -227,10 +227,10 @@ export async function* streamBatchEvaluation(pipeline, inputs, config) {
     const passed = successfulResults.filter((r) => r.result.passed);
     return {
         total: inputs.length,
-        successful: successfulResults.length,
+        succeeded: successfulResults.length,
         failed: results.length - successfulResults.length,
         averageScore: scores.length > 0 ? scores.reduce((a, b) => a + b, 0) / scores.length : 0,
-        passRate: successfulResults.length > 0
+        passingRate: successfulResults.length > 0
             ? passed.length / successfulResults.length
             : 0,
         totalDuration: Date.now() - startTime,

package/dist/lib/evaluation/ragasEvaluator.js

@@ -2,6 +2,8 @@ import { AIProviderFactory } from "../core/factory.js";
 import { PromptBuilder } from "./prompts.js";
 import { logger } from "../utils/logger.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../observability/index.js";
+import { withSpan } from "../telemetry/withSpan.js";
+import { tracers } from "../telemetry/tracers.js";
 /**
  * Implements a RAGAS-style evaluator that uses a "judge" LLM to score the
  * quality of an AI response based on rich, contextual information.
@@ -33,45 +35,60 @@ export class RAGASEvaluator {
      * @returns A promise that resolves to a detailed `EvaluationResult`.
      */
     async evaluate(context) {
-        const span = SpanSerializer.createSpan(SpanType.EVALUATION, "evaluation.ragas", {
-            "evaluation.dimension": "relevance|accuracy|completeness",
-            "ai.provider": this.providerName,
-            "ai.model": this.evaluationModel,
-        });
-        const startTime = Date.now();
-        try {
-            const prompt = this.promptBuilder.buildEvaluationPrompt(context, this.promptGenerator);
-            const provider = await AIProviderFactory.createProvider(this.providerName, this.evaluationModel);
-            const result = await provider.generate({
-                input: { text: prompt },
+        return withSpan({
+            name: "neurolink.evaluation.ragas",
+            tracer: tracers.sdk,
+            attributes: {
+                "evaluation.provider": this.providerName,
+                "evaluation.model": this.evaluationModel,
+            },
+        }, async (otelSpan) => {
+            const span = SpanSerializer.createSpan(SpanType.EVALUATION, "evaluation.ragas", {
+                "evaluation.dimension": "relevance|accuracy|completeness",
+                "ai.provider": this.providerName,
+                "ai.model": this.evaluationModel,
             });
-            if (!result) {
-                throw new Error("Evaluation generation failed to return a result.");
+            const startTime = Date.now();
+            try {
+                const prompt = this.promptBuilder.buildEvaluationPrompt(context, this.promptGenerator);
+                const provider = await AIProviderFactory.createProvider(this.providerName, this.evaluationModel);
+                const result = await provider.generate({
+                    input: { text: prompt },
+                });
+                if (!result) {
+                    throw new Error("Evaluation generation failed to return a result.");
+                }
+                const rawEvaluationResponse = result.content;
+                const parsedResult = this.parseEvaluationResponse(rawEvaluationResponse);
+                const evaluationTime = Date.now() - startTime;
+                const finalResult = {
+                    ...parsedResult,
+                    isPassing: parsedResult.finalScore >= this.threshold, // This will be recalculated, but is needed for the type
+                    evaluationModel: this.evaluationModel,
+                    evaluationTime,
+                    attemptNumber: context.attemptNumber,
+                    rawEvaluationResponse,
+                };
+                // Write evaluation scores to OTel span for Langfuse visibility
+                otelSpan.setAttribute("evaluation.relevance_score", finalResult.relevanceScore);
+                otelSpan.setAttribute("evaluation.accuracy_score", finalResult.accuracyScore);
+                otelSpan.setAttribute("evaluation.completeness_score", finalResult.completenessScore);
+                otelSpan.setAttribute("evaluation.final_score", finalResult.finalScore);
+                otelSpan.setAttribute("evaluation.is_passing", finalResult.isPassing);
+                span.durationMs = Date.now() - startTime;
+                const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
+                getMetricsAggregator().recordSpan(endedSpan);
+                return finalResult;
             }
-            const rawEvaluationResponse = result.content;
-            const parsedResult = this.parseEvaluationResponse(rawEvaluationResponse);
-            const evaluationTime = Date.now() - startTime;
-            const finalResult = {
-                ...parsedResult,
-                isPassing: parsedResult.finalScore >= this.threshold, // This will be recalculated, but is needed for the type
-                evaluationModel: this.evaluationModel,
-                evaluationTime,
-                attemptNumber: context.attemptNumber,
-                rawEvaluationResponse,
-            };
-            span.durationMs = Date.now() - startTime;
-            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
-            getMetricsAggregator().recordSpan(endedSpan);
-            return finalResult;
-        }
-        catch (error) {
-            span.durationMs = Date.now() - startTime;
-            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR);
-            endedSpan.statusMessage =
-                error instanceof Error ? error.message : String(error);
-            getMetricsAggregator().recordSpan(endedSpan);
-            throw error;
-        }
+            catch (error) {
+                span.durationMs = Date.now() - startTime;
+                const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR);
+                endedSpan.statusMessage =
+                    error instanceof Error ? error.message : String(error);
+                getMetricsAggregator().recordSpan(endedSpan);
+                throw error;
+            }
+        }); // end withSpan
     }
     /**
      * Parses the raw JSON string from the judge LLM into a structured `EvaluationResult` object.