observability-toolkit 2.0.0 → 2.1.1

package/dist/lib/evaluation-hooks.test.js

@@ -1,624 +0,0 @@
-/**
- * Tests for evaluation-hooks.ts
- *
- * Covers: HMAC signature validation, payload validation, JSONL conversion,
- * single/batch processing, and edge cases.
- */
-import { describe, it, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert';
-import { createHmac } from 'crypto';
-import { mkdirSync, rmSync, readFileSync, existsSync, readdirSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { verifyHmacSignature, validateEvaluationPayload, payloadToJsonlRecord, processEvaluation, processBatch, resetHookStats, getHookStats, MAX_BATCH_SIZE, MAX_BATCH_BYTES, MAX_SINGLE_EVALUATION_BYTES, } from './evaluation-hooks.js';
-import { normalizeScore } from '../types/evaluation-hooks.js';
-// Test helper for creating temp directories
-function createTempDir() {
-    const dir = join(tmpdir(), `eval-hooks-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(dir, { recursive: true });
-    return dir;
-}
-function removeTempDir(dir) {
-    try {
-        rmSync(dir, { recursive: true, force: true });
-    }
-    catch {
-        // Ignore cleanup errors
-    }
-}
-describe('evaluation-hooks', () => {
-    describe('verifyHmacSignature', () => {
-        const secret = 'test-secret-key';
-        const payload = '{"evaluationName":"test","scoreValue":0.8}';
-        function generateSignature(data, key) {
-            return 'sha256=' + createHmac('sha256', key).update(data).digest('hex');
-        }
-        it('should verify valid HMAC signature', () => {
-            const signature = generateSignature(payload, secret);
-            const result = verifyHmacSignature(payload, signature, secret);
-            assert.strictEqual(result.valid, true);
-            assert.strictEqual(result.algorithm, 'sha256');
-        });
-        it('should reject missing signature', () => {
-            const result = verifyHmacSignature(payload, '', secret);
-            assert.strictEqual(result.valid, false);
-            assert.ok(result.error?.includes('Missing signature'));
-        });
-        it('should reject invalid signature format', () => {
-            const result = verifyHmacSignature(payload, 'invalid-format', secret);
-            assert.strictEqual(result.valid, false);
-            assert.ok(result.error?.includes('Invalid signature format'));
-        });
-        it('should reject signature without sha256= prefix', () => {
-            const hex = createHmac('sha256', secret).update(payload).digest('hex');
-            const result = verifyHmacSignature(payload, hex, secret);
-            assert.strictEqual(result.valid, false);
-            assert.ok(result.error?.includes('Invalid signature format'));
-        });
-        it('should reject signature with wrong hex length', () => {
-            const result = verifyHmacSignature(payload, 'sha256=abc123', secret);
-            assert.strictEqual(result.valid, false);
-            assert.ok(result.error?.includes('expected 64 hex chars'));
-        });
-        it('should reject signature with non-hex characters', () => {
-            const result = verifyHmacSignature(payload, 'sha256=' + 'g'.repeat(64), secret);
-            assert.strictEqual(result.valid, false);
-            assert.ok(result.error?.includes('expected 64 hex chars'));
-        });
-        it('should reject signature mismatch (wrong secret)', () => {
-            const signature = generateSignature(payload, 'wrong-secret');
-            const result = verifyHmacSignature(payload, signature, secret);
-            assert.strictEqual(result.valid, false);
-            assert.ok(result.error?.includes('Signature mismatch'));
-        });
-        it('should reject signature mismatch (modified payload)', () => {
-            const signature = generateSignature(payload, secret);
-            const result = verifyHmacSignature('modified-payload', signature, secret);
-            assert.strictEqual(result.valid, false);
-            assert.ok(result.error?.includes('Signature mismatch'));
-        });
-        it('should track signature failures in stats', () => {
-            resetHookStats();
-            const badSignature = 'sha256=' + 'a'.repeat(64);
-            verifyHmacSignature(payload, badSignature, secret);
-            const stats = getHookStats();
-            assert.strictEqual(stats.signatureFailures, 1);
-        });
-        it('should handle empty payload', () => {
-            const emptyPayload = '';
-            const signature = generateSignature(emptyPayload, secret);
-            const result = verifyHmacSignature(emptyPayload, signature, secret);
-            assert.strictEqual(result.valid, true);
-        });
-        it('should handle unicode payload', () => {
-            const unicodePayload = '{"text":"hello \ud83d\ude00 world"}';
-            const signature = generateSignature(unicodePayload, secret);
-            const result = verifyHmacSignature(unicodePayload, signature, secret);
-            assert.strictEqual(result.valid, true);
-        });
-    });
-    describe('validateEvaluationPayload', () => {
-        const validPayload = {
-            evaluationName: 'relevance',
-            scoreValue: 0.85,
-            evaluator: 'claude-3-sonnet',
-            evaluatorType: 'llm',
-        };
-        it('should accept valid payload', () => {
-            const errors = validateEvaluationPayload(validPayload);
-            assert.strictEqual(errors.length, 0);
-        });
-        it('should require evaluationName', () => {
-            const payload = { ...validPayload, evaluationName: '' };
-            const errors = validateEvaluationPayload(payload);
-            assert.ok(errors.some(e => e.field === 'evaluationName'));
-        });
-        it('should require evaluator', () => {
-            const payload = { ...validPayload, evaluator: '' };
-            const errors = validateEvaluationPayload(payload);
-            assert.ok(errors.some(e => e.field === 'evaluator'));
-        });
-        it('should require evaluatorType', () => {
-            const payload = { ...validPayload, evaluatorType: 'invalid' };
-            const errors = validateEvaluationPayload(payload);
-            assert.ok(errors.some(e => e.field === 'evaluatorType'));
-        });
-        it('should require scoreValue or scoreLabel', () => {
-            const payload = { ...validPayload, scoreValue: undefined, scoreLabel: undefined };
-            const errors = validateEvaluationPayload(payload);
-            assert.ok(errors.some(e => e.field === 'scoreValue/scoreLabel'));
-        });
-        it('should accept scoreLabel without scoreValue', () => {
-            const payload = { ...validPayload, scoreValue: undefined, scoreLabel: 'pass' };
-            const errors = validateEvaluationPayload(payload);
-            assert.strictEqual(errors.length, 0);
-        });
-        it('should reject non-finite scoreValue', () => {
-            const payload = { ...validPayload, scoreValue: NaN };
-            const errors = validateEvaluationPayload(payload);
-            assert.ok(errors.some(e => e.field === 'scoreValue'));
-        });
-        it('should reject Infinity scoreValue', () => {
-            const payload = { ...validPayload, scoreValue: Infinity };
-            const errors = validateEvaluationPayload(payload);
-            assert.ok(errors.some(e => e.field === 'scoreValue'));
-        });
-        it('should reject oversized evaluationName', () => {
-            const payload = { ...validPayload, evaluationName: 'x'.repeat(257) };
-            const errors = validateEvaluationPayload(payload);
-            assert.ok(errors.some(e => e.field === 'evaluationName' && e.message.includes('maximum length')));
-        });
-        it('should reject oversized explanation', () => {
-            const payload = { ...validPayload, explanation: 'x'.repeat(10241) };
-            const errors = validateEvaluationPayload(payload);
-            assert.ok(errors.some(e => e.field === 'explanation'));
-        });
-        it('should validate stepScores structure', () => {
-            const payload = {
-                ...validPayload,
-                stepScores: [{ step: 'invalid' }], // Missing score
-            };
-            const errors = validateEvaluationPayload(payload);
-            assert.ok(errors.some(e => e.field.includes('stepScores')));
-        });
-        it('should accept valid stepScores', () => {
-            const payload = {
-                ...validPayload,
-                stepScores: [
-                    { step: 0, score: 0.9 },
-                    { step: 'reasoning', score: 0.8 },
-                ],
-            };
-            const errors = validateEvaluationPayload(payload);
-            assert.strictEqual(errors.length, 0);
-        });
-        it('should validate toolVerifications structure', () => {
-            const payload = {
-                ...validPayload,
-                toolVerifications: [{ toolName: 'test' }], // Missing required fields
-            };
-            const errors = validateEvaluationPayload(payload);
-            assert.ok(errors.some(e => e.field.includes('toolVerifications')));
-        });
-        it('should accept valid toolVerifications', () => {
-            const payload = {
-                ...validPayload,
-                toolVerifications: [
-                    { toolName: 'search', toolCorrect: true, argsCorrect: true, score: 1.0 },
-                ],
-            };
-            const errors = validateEvaluationPayload(payload);
-            assert.strictEqual(errors.length, 0);
-        });
-        it('should reject negative trajectoryLength', () => {
-            const payload = { ...validPayload, trajectoryLength: -1 };
-            const errors = validateEvaluationPayload(payload);
-            assert.ok(errors.some(e => e.field === 'trajectoryLength'));
-        });
-        it('should include index in batch validation', () => {
-            const errors = validateEvaluationPayload({ ...validPayload, evaluationName: '' }, 5);
-            assert.ok(errors.some(e => e.index === 5));
-        });
-        it('should reject oversized payload', () => {
-            const largePayload = {
-                ...validPayload,
-                metadata: { data: 'x'.repeat(MAX_SINGLE_EVALUATION_BYTES) },
-            };
-            const errors = validateEvaluationPayload(largePayload);
-            assert.ok(errors.some(e => e.field === 'payload' && e.message.includes('exceeds maximum')));
-        });
-    });
-    describe('normalizeScore', () => {
-        it('should clamp ratio_0_1 to 0-1', () => {
-            assert.strictEqual(normalizeScore(0.5), 0.5);
-            assert.strictEqual(normalizeScore(-0.5), 0);
-            assert.strictEqual(normalizeScore(1.5), 1);
-        });
-        it('should handle undefined unit', () => {
-            assert.strictEqual(normalizeScore(0.7, undefined), 0.7);
-        });
-        it('should convert percentage to 0-1', () => {
-            assert.strictEqual(normalizeScore(50, 'percentage'), 0.5);
-            assert.strictEqual(normalizeScore(100, 'percentage'), 1);
-            assert.strictEqual(normalizeScore(0, 'percentage'), 0);
-        });
-        it('should convert stars_5 to 0-1', () => {
-            assert.strictEqual(normalizeScore(5, 'stars_5'), 1);
-            assert.strictEqual(normalizeScore(0, 'stars_5'), 0);
-            assert.strictEqual(normalizeScore(2.5, 'stars_5'), 0.5);
-        });
-        it('should convert likert_5 to 0-1', () => {
-            assert.strictEqual(normalizeScore(5, 'likert_5'), 1);
-            assert.strictEqual(normalizeScore(1, 'likert_5'), 0);
-            assert.strictEqual(normalizeScore(3, 'likert_5'), 0.5);
-        });
-        it('should handle unknown unit as ratio_0_1', () => {
-            assert.strictEqual(normalizeScore(0.6, 'unknown_unit'), 0.6);
-        });
-        it('should handle NaN', () => {
-            assert.strictEqual(normalizeScore(NaN), 0);
-        });
-        it('should handle Infinity', () => {
-            assert.strictEqual(normalizeScore(Infinity), 0);
-            assert.strictEqual(normalizeScore(-Infinity), 0);
-        });
-        it('should handle division by zero (inputMin === inputMax)', () => {
-            // This edge case would require a custom config, but the function handles it
-            // by returning 0.5 if value equals the single valid value
-            // Tested indirectly - the implementation guards against this
-            assert.strictEqual(normalizeScore(0.5, 'ratio_0_1'), 0.5);
-        });
-    });
-    describe('payloadToJsonlRecord', () => {
-        const payload = {
-            evaluationName: 'relevance',
-            scoreValue: 0.85,
-            scoreLabel: 'pass',
-            evaluator: 'claude-3-sonnet',
-            evaluatorType: 'llm',
-            explanation: 'Response is relevant',
-        };
-        it('should create valid JSON record', () => {
-            const record = payloadToJsonlRecord(payload);
-            const parsed = JSON.parse(record);
-            assert.strictEqual(parsed.name, 'gen_ai.evaluation.result');
-            assert.ok(parsed.timestamp);
-            assert.ok(parsed.attributes);
-        });
-        it('should include all standard attributes', () => {
-            const record = payloadToJsonlRecord(payload);
-            const parsed = JSON.parse(record);
-            const attrs = parsed.attributes;
-            assert.strictEqual(attrs['gen_ai.evaluation.name'], 'relevance');
-            assert.strictEqual(attrs['gen_ai.evaluation.score.value'], 0.85);
-            assert.strictEqual(attrs['gen_ai.evaluation.score.label'], 'pass');
-            assert.strictEqual(attrs['gen_ai.evaluation.evaluator'], 'claude-3-sonnet');
-            assert.strictEqual(attrs['gen_ai.evaluation.evaluator.type'], 'llm');
-            assert.strictEqual(attrs['gen_ai.evaluation.explanation'], 'Response is relevant');
-        });
-        it('should use provided timestamp', () => {
-            const ts = '2026-01-01T00:00:00.000Z';
-            const record = payloadToJsonlRecord(payload, ts);
-            const parsed = JSON.parse(record);
-            assert.strictEqual(parsed.timestamp, ts);
-        });
-        it('should include traceId when provided', () => {
-            const payloadWithTrace = { ...payload, traceId: 'abc123' };
-            const record = payloadToJsonlRecord(payloadWithTrace);
-            const parsed = JSON.parse(record);
-            assert.strictEqual(parsed.traceId, 'abc123');
-        });
-        it('should include sessionId in attributes', () => {
-            const payloadWithSession = { ...payload, sessionId: 'sess-123' };
-            const record = payloadToJsonlRecord(payloadWithSession);
-            const parsed = JSON.parse(record);
-            assert.strictEqual(parsed.attributes['session.id'], 'sess-123');
-        });
-        it('should include Agent-as-Judge fields', () => {
-            const agentPayload = {
-                ...payload,
-                agentId: 'agent-1',
-                agentName: 'TestAgent',
-                stepScores: [{ step: 0, score: 0.9 }],
-                toolVerifications: [{ toolName: 'search', toolCorrect: true, argsCorrect: true, score: 1.0 }],
-                trajectoryLength: 5,
-            };
-            const record = payloadToJsonlRecord(agentPayload);
-            const parsed = JSON.parse(record);
-            const attrs = parsed.attributes;
-            assert.strictEqual(attrs['gen_ai.agent.id'], 'agent-1');
-            assert.strictEqual(attrs['gen_ai.agent.name'], 'TestAgent');
-            assert.ok(attrs['gen_ai.evaluation.step_scores']);
-            assert.ok(attrs['gen_ai.evaluation.tool_verifications']);
-            assert.strictEqual(attrs['gen_ai.evaluation.trajectory_length'], 5);
-        });
-        it('should normalize score based on unit', () => {
-            const percentagePayload = { ...payload, scoreValue: 85, scoreUnit: 'percentage' };
-            const record = payloadToJsonlRecord(percentagePayload);
-            const parsed = JSON.parse(record);
-            assert.strictEqual(parsed.attributes['gen_ai.evaluation.score.value'], 0.85);
-        });
-        it('should prefix custom metadata', () => {
-            const payloadWithMeta = {
-                ...payload,
-                metadata: { custom_field: 'value', number: 42 },
-            };
-            const record = payloadToJsonlRecord(payloadWithMeta);
-            const parsed = JSON.parse(record);
-            assert.strictEqual(parsed.attributes['webhook.metadata.custom_field'], 'value');
-            assert.strictEqual(parsed.attributes['webhook.metadata.number'], 42);
-        });
-    });
-    describe('processEvaluation', () => {
-        let tempDir;
-        let options;
-        beforeEach(() => {
-            tempDir = createTempDir();
-            options = { telemetryDir: tempDir };
-            resetHookStats();
-        });
-        afterEach(() => {
-            removeTempDir(tempDir);
-        });
-        const validPayload = {
-            evaluationName: 'relevance',
-            scoreValue: 0.85,
-            evaluator: 'claude-3-sonnet',
-            evaluatorType: 'llm',
-        };
-        it('should write evaluation to JSONL file', async () => {
-            const result = await processEvaluation(validPayload, options);
-            assert.strictEqual(result.success, true);
-            assert.strictEqual(result.processedCount, 1);
-            // Verify file was written
-            const files = readdirSync(tempDir);
-            assert.ok(files.some((f) => f.startsWith('evaluations-') && f.endsWith('.jsonl')));
-        });
-        it('should return validation errors for invalid payload', async () => {
-            const invalidPayload = { ...validPayload, evaluationName: '' };
-            const result = await processEvaluation(invalidPayload, options);
-            assert.strictEqual(result.success, false);
-            assert.ok(result.message.includes('Validation failed'));
-            assert.ok(result.errors && result.errors.length > 0);
-        });
-        it('should create telemetry directory if it does not exist', async () => {
-            const newDir = join(tempDir, 'nested', 'dir');
-            const newOptions = { telemetryDir: newDir };
-            await processEvaluation(validPayload, newOptions);
-            assert.ok(existsSync(newDir));
-        });
-        it('should update hook stats on success', async () => {
-            await processEvaluation(validPayload, options);
-            const stats = getHookStats();
-            assert.strictEqual(stats.totalReceived, 1);
-            assert.strictEqual(stats.successCount, 1);
-            assert.ok(stats.lastProcessedAt);
-        });
-        it('should update hook stats on validation failure', async () => {
-            const invalidPayload = { ...validPayload, evaluationName: '' };
-            await processEvaluation(invalidPayload, options);
-            const stats = getHookStats();
-            assert.strictEqual(stats.totalReceived, 1);
-            assert.strictEqual(stats.validationFailures, 1);
-        });
-        it('should write valid JSONL content', async () => {
-            await processEvaluation(validPayload, options);
-            const files = readdirSync(tempDir);
-            const evalFile = files.find((f) => f.startsWith('evaluations-'));
-            assert.ok(evalFile, 'Evaluations file should exist');
-            const content = readFileSync(join(tempDir, evalFile), 'utf-8');
-            const lines = content.trim().split('\n');
-            assert.strictEqual(lines.length, 1);
-            const record = JSON.parse(lines[0]);
-            assert.strictEqual(record.name, 'gen_ai.evaluation.result');
-            assert.strictEqual(record.attributes['gen_ai.evaluation.name'], 'relevance');
-        });
-    });
-    describe('processBatch', () => {
-        let tempDir;
-        let options;
-        beforeEach(() => {
-            tempDir = createTempDir();
-            options = { telemetryDir: tempDir };
-            resetHookStats();
-        });
-        afterEach(() => {
-            removeTempDir(tempDir);
-        });
-        const validPayload = {
-            evaluationName: 'relevance',
-            scoreValue: 0.85,
-            evaluator: 'claude-3-sonnet',
-            evaluatorType: 'llm',
-        };
-        it('should process batch of evaluations', async () => {
-            const batch = {
-                evaluations: [
-                    { ...validPayload, evaluationName: 'relevance' },
-                    { ...validPayload, evaluationName: 'faithfulness' },
-                    { ...validPayload, evaluationName: 'coherence' },
-                ],
-            };
-            const result = await processBatch(batch, options);
-            assert.strictEqual(result.success, true);
-            assert.strictEqual(result.processedCount, 3);
-        });
-        it('should reject empty batch', async () => {
-            const result = await processBatch({ evaluations: [] }, options);
-            assert.strictEqual(result.success, false);
-            assert.ok(result.message.includes('Empty batch'));
-        });
-        it('should reject batch exceeding size limit', async () => {
-            const batch = {
-                evaluations: Array(MAX_BATCH_SIZE + 1).fill(validPayload),
-            };
-            const result = await processBatch(batch, options);
-            assert.strictEqual(result.success, false);
-            assert.ok(result.message.includes('Batch too large'));
-        });
-        it('should reject batch if any evaluation fails validation', async () => {
-            const batch = {
-                evaluations: [
-                    validPayload,
-                    { ...validPayload, evaluationName: '' }, // Invalid
-                    validPayload,
-                ],
-            };
-            const result = await processBatch(batch, options);
-            assert.strictEqual(result.success, false);
-            assert.ok(result.errors && result.errors.length > 0);
-        });
-        it('should include indices in validation errors', async () => {
-            const batch = {
-                evaluations: [
-                    validPayload,
-                    { ...validPayload, evaluationName: '' }, // Invalid at index 1
-                ],
-            };
-            const result = await processBatch(batch, options);
-            assert.ok(result.errors?.some(e => e.index === 1));
-        });
-        it('should write all evaluations to same file', async () => {
-            const batch = {
-                evaluations: [
-                    { ...validPayload, evaluationName: 'eval1' },
-                    { ...validPayload, evaluationName: 'eval2' },
-                ],
-            };
-            await processBatch(batch, options);
-            const files = readdirSync(tempDir);
-            const evalFile = files.find((f) => f.startsWith('evaluations-'));
-            assert.ok(evalFile, 'Evaluations file should exist');
-            const content = readFileSync(join(tempDir, evalFile), 'utf-8');
-            const lines = content.trim().split('\n');
-            assert.strictEqual(lines.length, 2);
-        });
-        it('should reject batch exceeding byte size limit', async () => {
-            // Create payload that will exceed byte limit
-            const largeMetadata = { data: 'x'.repeat(50000) };
-            const batch = {
-                evaluations: Array(30).fill({
-                    ...validPayload,
-                    metadata: largeMetadata,
-                }),
-            };
-            const result = await processBatch(batch, options);
-            assert.strictEqual(result.success, false);
-            assert.ok(result.message.includes('too large') || result.message.includes('exceeds maximum'));
-        });
-        it('should update hook stats for batch', async () => {
-            const batch = { evaluations: [validPayload, validPayload, validPayload] };
-            await processBatch(batch, options);
-            const stats = getHookStats();
-            assert.strictEqual(stats.totalReceived, 3);
-            assert.strictEqual(stats.successCount, 3);
-        });
-        it('should reject invalid evaluations array', async () => {
-            const result = await processBatch({ evaluations: 'not an array' }, options);
-            assert.strictEqual(result.success, false);
-            assert.ok(result.message.includes('must be an array'));
-        });
-    });
-    describe('resetHookStats', () => {
-        it('should reset all stats to zero', async () => {
-            const tempDir = createTempDir();
-            const options = { telemetryDir: tempDir };
-            const validPayload = {
-                evaluationName: 'test',
-                scoreValue: 0.5,
-                evaluator: 'test',
-                evaluatorType: 'llm',
-            };
-            // Generate some stats
-            await processEvaluation(validPayload, options);
-            resetHookStats();
-            const stats = getHookStats();
-            assert.strictEqual(stats.totalReceived, 0);
-            assert.strictEqual(stats.successCount, 0);
-            assert.strictEqual(stats.validationFailures, 0);
-            assert.strictEqual(stats.signatureFailures, 0);
-            assert.strictEqual(stats.deduplicatedCount, 0);
-            removeTempDir(tempDir);
-        });
-    });
-    describe('constants', () => {
-        it('should export MAX_BATCH_SIZE', () => {
-            assert.strictEqual(typeof MAX_BATCH_SIZE, 'number');
-            assert.ok(MAX_BATCH_SIZE > 0);
-        });
-        it('should export MAX_BATCH_BYTES', () => {
-            assert.strictEqual(typeof MAX_BATCH_BYTES, 'number');
-            assert.ok(MAX_BATCH_BYTES > 0);
-        });
-        it('should export MAX_SINGLE_EVALUATION_BYTES', () => {
-            assert.strictEqual(typeof MAX_SINGLE_EVALUATION_BYTES, 'number');
-            assert.ok(MAX_SINGLE_EVALUATION_BYTES > 0);
-        });
-    });
-    describe('edge cases', () => {
-        let tempDir;
-        let options;
-        beforeEach(() => {
-            tempDir = createTempDir();
-            options = { telemetryDir: tempDir };
-            resetHookStats();
-        });
-        afterEach(() => {
-            removeTempDir(tempDir);
-        });
-        it('should handle unicode in evaluation names', async () => {
-            const payload = {
-                evaluationName: 'test-\u65e5\u672c\u8a9e',
-                scoreValue: 0.8,
-                evaluator: 'test',
-                evaluatorType: 'llm',
-            };
-            const result = await processEvaluation(payload, options);
-            assert.strictEqual(result.success, true);
-        });
-        it('should handle special characters in explanation', async () => {
-            const payload = {
-                evaluationName: 'test',
-                scoreValue: 0.8,
-                evaluator: 'test',
-                evaluatorType: 'llm',
-                explanation: 'Line1\nLine2\tTabbed"Quoted"\'Single\'',
-            };
-            const result = await processEvaluation(payload, options);
-            assert.strictEqual(result.success, true);
-        });
-        it('should handle boundary score values', async () => {
-            const payloads = [
-                { ...createPayload(), scoreValue: 0 },
-                { ...createPayload(), scoreValue: 1 },
-                { ...createPayload(), scoreValue: 0.0000001 },
-                { ...createPayload(), scoreValue: 0.9999999 },
-            ];
-            for (const payload of payloads) {
-                const result = await processEvaluation(payload, options);
-                assert.strictEqual(result.success, true);
-            }
-        });
-        it('should handle all evaluator types', async () => {
-            const types = ['llm', 'human', 'rule', 'classifier'];
-            for (const evaluatorType of types) {
-                const payload = {
-                    evaluationName: 'test',
-                    scoreValue: 0.5,
-                    evaluator: 'test',
-                    evaluatorType,
-                };
-                const errors = validateEvaluationPayload(payload);
-                assert.strictEqual(errors.length, 0, `Failed for type: ${evaluatorType}`);
-            }
-        });
-        it('should handle concurrent writes', async () => {
-            const payload = {
-                evaluationName: 'test',
-                scoreValue: 0.8,
-                evaluator: 'test',
-                evaluatorType: 'llm',
-            };
-            // Write 10 evaluations concurrently
-            const promises = Array(10).fill(null).map(() => processEvaluation(payload, options));
-            const results = await Promise.all(promises);
-            assert.ok(results.every(r => r.success));
-            // Verify all were written
-            const files = readdirSync(tempDir);
-            const evalFile = files.find((f) => f.startsWith('evaluations-'));
-            assert.ok(evalFile, 'Evaluations file should exist');
-            const content = readFileSync(join(tempDir, evalFile), 'utf-8');
-            const lines = content.trim().split('\n');
-            assert.strictEqual(lines.length, 10);
-        });
-    });
-});
-function createPayload() {
-    return {
-        evaluationName: 'test',
-        scoreValue: 0.5,
-        evaluator: 'test',
-        evaluatorType: 'llm',
-    };
-}
-//# sourceMappingURL=evaluation-hooks.test.js.map