observability-toolkit 1.8.5 → 2.1.0

package/dist/lib/agent-judge/agent-eval-metrics.test.js

@@ -0,0 +1,676 @@
+/**
+ * Tests for Agent Evaluation Metrics
+ */
+import { describe, it } from 'vitest';
+import * as assert from 'node:assert';
+import { evaluateTaskCompletion, evaluateToolCorrectness, evaluateArgumentCorrectness, computeSingleTurnMetrics, evaluateConversationCompleteness, evaluateTurnRelevancy, evaluateHandoffCorrectness, computeMultiTurnMetrics, singleTurnMetricsToEvaluations, multiTurnMetricsToEvaluations, DEFAULT_SINGLE_TURN_WEIGHTS, DEFAULT_MULTI_TURN_WEIGHTS, SCORING_THRESHOLDS, TOOL_VERIFICATION_WEIGHTS, TASK_COMPLETION_WEIGHTS, } from './agent-eval-metrics.js';
+import { BINARY_SCALE_EXCELLENT_THRESHOLD, SCORE_BAND_ADEQUATE, SCORE_BAND_EXCELLENT, SCORE_BAND_GOOD, STEP_SCALE_ADEQUATE_THRESHOLD, TURN_ERROR_THRESHOLD, } from '../quality/quality-constants.js';
+import { COUNT_FIFTY, COUNT_FOUR, COUNT_HUNDRED, COUNT_TEN, COUNT_THOUSAND, COUNT_THREE, COUNT_TWO, } from '../../test-helpers/test-constants.js';
+describe('agent-eval-metrics', () => {
+    // ==========================================================================
+    // Single-Turn Metrics
+    // ==========================================================================
+    describe('evaluateTaskCompletion', () => {
+        it('scores high for complete response with tool results', () => {
+            const input = {
+                task: 'Get the weather',
+                response: 'The current weather in San Francisco is 65°F and sunny. Perfect for outdoor activities.',
+                toolCalls: [
+                    { name: 'get_weather', arguments: { city: 'San Francisco' }, result: { temp: 65, condition: 'sunny' } }
+                ],
+            };
+            const score = evaluateTaskCompletion(input);
+            assert.ok(score >= SCORE_BAND_GOOD, `Expected >= ${SCORE_BAND_GOOD}, got ${score}`);
+        });
+        it('scores lower for empty response', () => {
+            const input = {
+                task: 'Get the weather',
+                response: '',
+                toolCalls: [],
+            };
+            const score = evaluateTaskCompletion(input);
+            assert.ok(score <= TURN_ERROR_THRESHOLD, `Expected <= ${TURN_ERROR_THRESHOLD}, got ${score}`);
+        });
+        it('scores moderate for response without tools', () => {
+            const input = {
+                task: 'Say hello',
+                response: 'Hello! How can I help you today?',
+                toolCalls: [],
+            };
+            const score = evaluateTaskCompletion(input);
+            assert.ok(score >= STEP_SCALE_ADEQUATE_THRESHOLD && score <= SCORE_BAND_EXCELLENT);
+        });
+        it('penalizes tool calls without results', () => {
+            const input = {
+                task: 'Search for files',
+                response: 'Searching for files...',
+                toolCalls: [
+                    { name: 'search', arguments: { query: 'test' } } // No result
+                ],
+            };
+            const scoreWithoutResult = evaluateTaskCompletion(input);
+            const inputWithResult = {
+                ...input,
+                toolCalls: [
+                    { name: 'search', arguments: { query: 'test' }, result: ['file1.ts'] }
+                ],
+            };
+            const scoreWithResult = evaluateTaskCompletion(inputWithResult);
+            assert.ok(scoreWithResult > scoreWithoutResult);
+        });
+    });
+    describe('evaluateToolCorrectness', () => {
+        it('scores perfect when tools match expected', () => {
+            const input = {
+                task: 'Read file',
+                response: 'Content of file.ts',
+                expectedTools: ['read_file'],
+                toolCalls: [
+                    { name: 'read_file', arguments: { path: 'file.ts' }, result: 'content' }
+                ],
+            };
+            const { score, verifications } = evaluateToolCorrectness(input);
+            assert.strictEqual(score, 1);
+            assert.strictEqual(verifications.length, 1);
+            assert.strictEqual(verifications[0].toolCorrect, true);
+        });
+        it('scores zero when wrong tools used', () => {
+            const input = {
+                task: 'Read file',
+                response: 'Error',
+                expectedTools: ['read_file'],
+                toolCalls: [
+                    { name: 'write_file', arguments: { path: 'file.ts' }, result: 'ok' }
+                ],
+            };
+            const { score, verifications } = evaluateToolCorrectness(input);
+            assert.ok(score < 1);
+            assert.strictEqual(verifications[0].toolCorrect, false);
+        });
+        it('scores perfect when no tools expected or used', () => {
+            const input = {
+                task: 'Say hello',
+                response: 'Hello!',
+                toolCalls: [],
+            };
+            const { score } = evaluateToolCorrectness(input);
+            assert.strictEqual(score, 1);
+        });
+        it('scores zero when expected tools not used', () => {
+            const input = {
+                task: 'Read file',
+                response: 'I cannot read files',
+                expectedTools: ['read_file'],
+                toolCalls: [],
+            };
+            const { score } = evaluateToolCorrectness(input);
+            assert.strictEqual(score, 0);
+        });
+        it('includes argument and result correctness', () => {
+            const input = {
+                task: 'Search',
+                response: 'Found results',
+                toolCalls: [
+                    { name: 'search', arguments: { query: 'test' }, result: ['item1'] }
+                ],
+            };
+            const { verifications } = evaluateToolCorrectness(input);
+            assert.strictEqual(verifications[0].argsCorrect, true);
+            assert.strictEqual(verifications[0].resultCorrect, true);
+        });
+    });
+    describe('evaluateArgumentCorrectness', () => {
+        it('scores perfect for valid arguments', () => {
+            const input = {
+                task: 'Search',
+                response: 'Results',
+                toolCalls: [
+                    { name: 'search', arguments: { query: 'test', limit: 10 } }
+                ],
+            };
+            const score = evaluateArgumentCorrectness(input);
+            assert.strictEqual(score, 1);
+        });
+        it('penalizes empty argument values', () => {
+            const input = {
+                task: 'Search',
+                response: 'Results',
+                toolCalls: [
+                    { name: 'search', arguments: { query: '', limit: 10 } }
+                ],
+            };
+            const score = evaluateArgumentCorrectness(input);
+            assert.ok(score < 1);
+        });
+        it('handles null and undefined arguments', () => {
+            const input = {
+                task: 'Search',
+                response: 'Results',
+                toolCalls: [
+                    { name: 'search', arguments: { query: null, limit: undefined } }
+                ],
+            };
+            const score = evaluateArgumentCorrectness(input);
+            assert.ok(score < 1);
+        });
+        it('scores perfect for no tool calls', () => {
+            const input = {
+                task: 'Hello',
+                response: 'Hi',
+                toolCalls: [],
+            };
+            const score = evaluateArgumentCorrectness(input);
+            assert.strictEqual(score, 1);
+        });
+    });
+    describe('computeSingleTurnMetrics', () => {
+        it('computes all metrics', () => {
+            const input = {
+                task: 'Read config.json',
+                response: 'The config contains: { "debug": true }',
+                expectedTools: ['read_file'],
+                toolCalls: [
+                    { name: 'read_file', arguments: { path: 'config.json' }, result: { debug: true } }
+                ],
+            };
+            const metrics = computeSingleTurnMetrics(input);
+            assert.ok('taskCompletion' in metrics);
+            assert.ok('toolCorrectness' in metrics);
+            assert.ok('argumentCorrectness' in metrics);
+            assert.ok('overallScore' in metrics);
+            assert.ok('explanation' in metrics);
+            assert.ok(metrics.overallScore >= 0 && metrics.overallScore <= 1);
+        });
+        it('uses custom weights', () => {
+            const input = {
+                task: 'Test',
+                response: 'Result',
+                toolCalls: [],
+            };
+            computeSingleTurnMetrics(input);
+            const customMetrics = computeSingleTurnMetrics(input, {
+                taskCompletion: 1.0,
+                toolCorrectness: 0.0,
+                argumentCorrectness: 0.0,
+            });
+            // With all weight on task completion, overall should equal task completion
+            assert.strictEqual(customMetrics.overallScore, customMetrics.taskCompletion);
+        });
+        it('includes tool verifications', () => {
+            const input = {
+                task: 'Search',
+                response: 'Found',
+                toolCalls: [
+                    { name: 'search', arguments: { q: 'test' }, result: [] }
+                ],
+            };
+            const metrics = computeSingleTurnMetrics(input);
+            assert.strictEqual(metrics.toolVerifications.length, 1);
+        });
+    });
+    // ==========================================================================
+    // Multi-Turn Metrics
+    // ==========================================================================
+    describe('evaluateConversationCompleteness', () => {
+        it('scores high for complete conversation', () => {
+            const input = {
+                userIntent: 'Get help with code',
+                turns: [
+                    { index: 0, speaker: 'user', content: 'Help me fix this bug' },
+                    { index: 1, speaker: 'agent', content: 'I can help you with that. Let me analyze the code and suggest a fix. Here is the corrected version...' },
+                ],
+            };
+            const score = evaluateConversationCompleteness(input);
+            assert.ok(score >= BINARY_SCALE_EXCELLENT_THRESHOLD, `Expected >= ${BINARY_SCALE_EXCELLENT_THRESHOLD}, got ${score}`);
+        });
+        it('respects explicit satisfaction signal', () => {
+            const satisfied = {
+                userIntent: 'Get help',
+                turns: [],
+                userSatisfied: true,
+            };
+            const unsatisfied = {
+                userIntent: 'Get help',
+                turns: [],
+                userSatisfied: false,
+            };
+            assert.strictEqual(evaluateConversationCompleteness(satisfied), 1);
+            assert.strictEqual(evaluateConversationCompleteness(unsatisfied), 0);
+        });
+        it('scores zero for no agent responses', () => {
+            const input = {
+                userIntent: 'Get help',
+                turns: [
+                    { index: 0, speaker: 'user', content: 'Help me' },
+                ],
+            };
+            const score = evaluateConversationCompleteness(input);
+            assert.strictEqual(score, 0);
+        });
+    });
+    describe('evaluateTurnRelevancy', () => {
+        it('returns scores for agent turns', () => {
+            const input = {
+                userIntent: 'Code help',
+                turns: [
+                    { index: 0, speaker: 'user', content: 'How do I write a function?' },
+                    { index: 1, speaker: 'agent', content: 'To write a function in TypeScript, use the function keyword...' },
+                    { index: 2, speaker: 'user', content: 'Can you show an example?' },
+                    { index: 3, speaker: 'agent', content: 'Here is an example function that adds two numbers...' },
+                ],
+            };
+            const scores = evaluateTurnRelevancy(input);
+            assert.strictEqual(scores.length, COUNT_TWO); // 2 agent turns
+            for (const score of scores) {
+                assert.ok(score.score >= 0 && score.score <= 1);
+                assert.ok('explanation' in score);
+            }
+        });
+        it('scores higher for keyword matches', () => {
+            const input = {
+                userIntent: 'Weather check',
+                turns: [
+                    { index: 0, speaker: 'user', content: 'What is the weather in London?' },
+                    { index: 1, speaker: 'agent', content: 'The weather in London is currently cloudy with 15°C temperature.' },
+                ],
+            };
+            const scores = evaluateTurnRelevancy(input);
+            assert.ok(scores[0].score >= SCORE_BAND_ADEQUATE); // Should have keyword overlap
+        });
+    });
+    describe('evaluateHandoffCorrectness', () => {
+        it('returns null for no handoffs', () => {
+            const input = {
+                userIntent: 'Help',
+                turns: [],
+            };
+            assert.strictEqual(evaluateHandoffCorrectness(input), null);
+        });
+        it('uses explicit annotations when present', () => {
+            const input = {
+                userIntent: 'Complex task',
+                turns: [],
+                handoffs: [
+                    { fromAgent: 'agent1', toAgent: 'agent2', reason: 'Needs specialist', wasAppropriate: true },
+                    { fromAgent: 'agent2', toAgent: 'agent3', reason: 'Error', wasAppropriate: false },
+                ],
+            };
+            const score = evaluateHandoffCorrectness(input);
+            assert.strictEqual(score, STEP_SCALE_ADEQUATE_THRESHOLD); // 1/2 appropriate
+        });
+        it('falls back to heuristics', () => {
+            const input = {
+                userIntent: 'Help',
+                turns: [],
+                handoffs: [
+                    { fromAgent: 'a1', toAgent: 'a2', reason: 'This requires a specialist in database optimization' },
+                    { fromAgent: 'a2', toAgent: 'a3', reason: '' },
+                ],
+            };
+            const score = evaluateHandoffCorrectness(input);
+            assert.strictEqual(score, STEP_SCALE_ADEQUATE_THRESHOLD); // 1 with reason, 1 without
+        });
+    });
+    describe('computeMultiTurnMetrics', () => {
+        it('computes all metrics', () => {
+            const input = {
+                userIntent: 'Get weather',
+                turns: [
+                    { index: 0, speaker: 'user', content: 'What is the weather today?' },
+                    { index: 1, speaker: 'agent', content: 'The weather today is sunny and warm.' },
+                ],
+            };
+            const metrics = computeMultiTurnMetrics(input);
+            assert.ok('conversationCompleteness' in metrics);
+            assert.ok('turnRelevancy' in metrics);
+            assert.ok('handoffCorrectness' in metrics);
+            assert.ok('overallScore' in metrics);
+            assert.ok('turnScores' in metrics);
+            assert.ok('turnCount' in metrics);
+            assert.ok('explanation' in metrics);
+        });
+        it('excludes handoff from overall when null', () => {
+            const input = {
+                userIntent: 'Help',
+                turns: [
+                    { index: 0, speaker: 'user', content: 'Help' },
+                    { index: 1, speaker: 'agent', content: 'I can help you with many things.' },
+                ],
+            };
+            const metrics = computeMultiTurnMetrics(input);
+            assert.strictEqual(metrics.handoffCorrectness, null);
+            // Overall should still be computed from completeness and relevancy
+            assert.ok(metrics.overallScore >= 0);
+        });
+        it('uses custom weights', () => {
+            const input = {
+                userIntent: 'Test',
+                turns: [
+                    { index: 0, speaker: 'user', content: 'Test' },
+                    { index: 1, speaker: 'agent', content: 'Testing response' },
+                ],
+            };
+            const metrics = computeMultiTurnMetrics(input, {
+                conversationCompleteness: 1.0,
+                turnRelevancy: 0.0,
+                handoffCorrectness: 0.0,
+            });
+            // With all weight on completeness, overall should equal completeness
+            assert.strictEqual(metrics.overallScore, metrics.conversationCompleteness);
+        });
+    });
+    // ==========================================================================
+    // Conversion Functions
+    // ==========================================================================
+    describe('singleTurnMetricsToEvaluations', () => {
+        it('converts metrics to evaluation results', () => {
+            const input = {
+                task: 'Test',
+                response: 'Result',
+                toolCalls: [],
+            };
+            const metrics = computeSingleTurnMetrics(input);
+            const evaluations = singleTurnMetricsToEvaluations(metrics, {
+                sessionId: 'session-1',
+                agentId: 'agent-1',
+            });
+            assert.strictEqual(evaluations.length, COUNT_FOUR);
+            const names = evaluations.map(e => e.evaluationName);
+            assert.ok(names.includes('task_completion'));
+            assert.ok(names.includes('tool_correctness'));
+            assert.ok(names.includes('argument_correctness'));
+            assert.ok(names.includes('agent_overall'));
+            for (const e of evaluations) {
+                assert.ok(e.timestamp);
+                assert.strictEqual(e.sessionId, 'session-1');
+                assert.strictEqual(e.agentId, 'agent-1');
+                assert.ok(e.scoreValue !== undefined);
+                assert.ok(e.scoreLabel);
+            }
+        });
+    });
+    describe('multiTurnMetricsToEvaluations', () => {
+        it('converts metrics to evaluation results', () => {
+            const input = {
+                userIntent: 'Help',
+                turns: [
+                    { index: 0, speaker: 'user', content: 'Help me' },
+                    { index: 1, speaker: 'agent', content: 'I can help you' },
+                ],
+            };
+            const metrics = computeMultiTurnMetrics(input);
+            const evaluations = multiTurnMetricsToEvaluations(metrics, {
+                evaluator: 'test-evaluator',
+                evaluatorType: 'rule',
+            });
+            // 3 metrics (no handoff)
+            assert.strictEqual(evaluations.length, COUNT_THREE);
+            const names = evaluations.map(e => e.evaluationName);
+            assert.ok(names.includes('conversation_completeness'));
+            assert.ok(names.includes('turn_relevancy'));
+            assert.ok(names.includes('conversation_overall'));
+        });
+        it('includes handoff evaluation when present', () => {
+            const input = {
+                userIntent: 'Complex task',
+                turns: [],
+                handoffs: [
+                    { fromAgent: 'a1', toAgent: 'a2', reason: 'Specialist needed', wasAppropriate: true },
+                ],
+            };
+            const metrics = computeMultiTurnMetrics(input);
+            const evaluations = multiTurnMetricsToEvaluations(metrics);
+            // 4 metrics (includes handoff)
+            assert.strictEqual(evaluations.length, COUNT_FOUR);
+            const handoffEval = evaluations.find(e => e.evaluationName === 'handoff_correctness');
+            assert.ok(handoffEval);
+            assert.strictEqual(handoffEval.scoreValue, 1);
+        });
+    });
+    // ==========================================================================
+    // Default Weights
+    // ==========================================================================
+    describe('DEFAULT_SINGLE_TURN_WEIGHTS', () => {
+        it('sums to 1', () => {
+            const sum = DEFAULT_SINGLE_TURN_WEIGHTS.taskCompletion +
+                DEFAULT_SINGLE_TURN_WEIGHTS.toolCorrectness +
+                DEFAULT_SINGLE_TURN_WEIGHTS.argumentCorrectness;
+            assert.strictEqual(sum, 1);
+        });
+    });
+    describe('DEFAULT_MULTI_TURN_WEIGHTS', () => {
+        it('sums to 1', () => {
+            const sum = DEFAULT_MULTI_TURN_WEIGHTS.conversationCompleteness +
+                DEFAULT_MULTI_TURN_WEIGHTS.turnRelevancy +
+                DEFAULT_MULTI_TURN_WEIGHTS.handoffCorrectness;
+            assert.strictEqual(sum, 1);
+        });
+    });
+    // ==========================================================================
+    // Input Validation
+    // ==========================================================================
+    describe('input validation', () => {
+        it('throws on null input for evaluateTaskCompletion', () => {
+            assert.throws(() => {
+                evaluateTaskCompletion(null);
+            }, TypeError);
+        });
+        it('throws on missing task field', () => {
+            assert.throws(() => {
+                evaluateTaskCompletion({ response: 'hi', toolCalls: [] });
+            }, /task must be a string/);
+        });
+        it('throws on missing response field', () => {
+            assert.throws(() => {
+                evaluateTaskCompletion({ task: 'hi', toolCalls: [] });
+            }, /response must be a string/);
+        });
+        it('throws on missing toolCalls array', () => {
+            assert.throws(() => {
+                evaluateTaskCompletion({ task: 'hi', response: 'hello' });
+            }, /toolCalls must be an array/);
+        });
+        it('throws on null input for evaluateConversationCompleteness', () => {
+            assert.throws(() => {
+                evaluateConversationCompleteness(null);
+            }, TypeError);
+        });
+        it('throws on invalid speaker value', () => {
+            assert.throws(() => {
+                evaluateConversationCompleteness({
+                    userIntent: 'help',
+                    turns: [{ index: 0, speaker: 'admin', content: 'hi' }],
+                });
+            }, /speaker must be "user" or "agent"/);
+        });
+    });
+    // ==========================================================================
+    // Weight Validation
+    // ==========================================================================
+    describe('weight validation', () => {
+        const validInput = {
+            task: 'Test',
+            response: 'Response',
+            toolCalls: [],
+        };
+        const validMultiInput = {
+            userIntent: 'Help',
+            turns: [
+                { index: 0, speaker: 'user', content: 'Help' },
+                { index: 1, speaker: 'agent', content: 'Helping' },
+            ],
+        };
+        it('throws when weight sum is zero', () => {
+            assert.throws(() => {
+                computeSingleTurnMetrics(validInput, {
+                    taskCompletion: 0,
+                    toolCorrectness: 0,
+                    argumentCorrectness: 0,
+                });
+            }, /Weight sum must be positive/);
+        });
+        it('throws on negative weights', () => {
+            assert.throws(() => {
+                computeSingleTurnMetrics(validInput, {
+                    taskCompletion: -0.5,
+                    toolCorrectness: 0.5,
+                    argumentCorrectness: 0.5,
+                });
+            }, /non-negative finite numbers/);
+        });
+        it('throws on NaN weights', () => {
+            assert.throws(() => {
+                computeSingleTurnMetrics(validInput, {
+                    taskCompletion: NaN,
+                    toolCorrectness: 0.5,
+                    argumentCorrectness: 0.5,
+                });
+            }, /non-negative finite numbers/);
+        });
+        it('throws on Infinity weights', () => {
+            assert.throws(() => {
+                computeMultiTurnMetrics(validMultiInput, {
+                    conversationCompleteness: Infinity,
+                    turnRelevancy: 0.5,
+                    handoffCorrectness: 0.5,
+                });
+            }, /non-negative finite numbers/);
+        });
+        it('accepts valid custom weights', () => {
+            const result = computeSingleTurnMetrics(validInput, {
+                taskCompletion: 0.8,
+                toolCorrectness: 0.1,
+                argumentCorrectness: 0.1,
+            });
+            assert.ok(result.overallScore >= 0 && result.overallScore <= 1);
+        });
+    });
+    // ==========================================================================
+    // Security: Prototype Pollution Protection
+    // ==========================================================================
+    describe('prototype pollution protection', () => {
+        it('rejects arguments with __proto__ key', () => {
+            const input = {
+                task: 'Test',
+                response: 'Response',
+                toolCalls: [
+                    {
+                        name: 'test',
+                        arguments: { __proto__: { polluted: true }, value: 1 },
+                    },
+                ],
+            };
+            // Should score low because args are considered unsafe
+            const { score } = evaluateToolCorrectness(input);
+            assert.ok(score < 1, 'Should reject args with __proto__');
+        });
+        it('rejects arguments with constructor key', () => {
+            const input = {
+                task: 'Test',
+                response: 'Response',
+                toolCalls: [
+                    {
+                        name: 'test',
+                        arguments: { constructor: { polluted: true }, value: 1 },
+                    },
+                ],
+            };
+            const score = evaluateArgumentCorrectness(input);
+            assert.strictEqual(score, 0, 'Should reject args with constructor');
+        });
+        it('accepts normal arguments objects', () => {
+            const input = {
+                task: 'Test',
+                response: 'Response',
+                toolCalls: [
+                    {
+                        name: 'test',
+                        arguments: { path: '/file.ts', content: 'hello' },
+                        result: 'ok',
+                    },
+                ],
+            };
+            const { score } = evaluateToolCorrectness(input);
+            assert.strictEqual(score, 1, 'Should accept normal args');
+        });
+    });
+    // ==========================================================================
+    // Scoring Constants
+    // ==========================================================================
+    describe('scoring constants', () => {
+        it('has reasonable content length limit', () => {
+            assert.ok(SCORING_THRESHOLDS.MAX_CONTENT_LENGTH >= COUNT_THOUSAND);
+            assert.ok(SCORING_THRESHOLDS.MAX_CONTENT_LENGTH <= COUNT_HUNDRED * COUNT_THOUSAND);
+        });
+        it('has reasonable word count limit', () => {
+            assert.ok(SCORING_THRESHOLDS.MAX_WORD_COUNT >= COUNT_HUNDRED);
+            assert.ok(SCORING_THRESHOLDS.MAX_WORD_COUNT <= COUNT_TEN * COUNT_THOUSAND);
+        });
+        it('tool verification weights sum to 1', () => {
+            const sum = TOOL_VERIFICATION_WEIGHTS.TOOL_CORRECT +
+                TOOL_VERIFICATION_WEIGHTS.ARGS_CORRECT +
+                TOOL_VERIFICATION_WEIGHTS.RESULT_CORRECT;
+            assert.strictEqual(sum, 1);
+        });
+        it('task completion weights sum to 1', () => {
+            const sum = TASK_COMPLETION_WEIGHTS.HAS_RESPONSE +
+                TASK_COMPLETION_WEIGHTS.SUBSTANTIVE_RESPONSE +
+                TASK_COMPLETION_WEIGHTS.HAS_TOOL_CALLS +
+                TASK_COMPLETION_WEIGHTS.TOOL_RESULTS_COMPLETE;
+            assert.strictEqual(sum, 1);
+        });
+    });
+    // ==========================================================================
+    // DoS Protection
+    // ==========================================================================
+    describe('DoS protection', () => {
+        it('handles very long content gracefully', () => {
+            const longContent = 'word '.repeat(COUNT_FIFTY * COUNT_THOUSAND);
+            const input = {
+                userIntent: 'Help',
+                turns: [
+                    { index: 0, speaker: 'user', content: longContent },
+                    { index: 1, speaker: 'agent', content: longContent },
+                ],
+            };
+            // Should not hang or throw
+            const startTime = Date.now();
+            const scores = evaluateTurnRelevancy(input);
+            const elapsed = Date.now() - startTime;
+            assert.ok(elapsed < COUNT_THOUSAND, `Should complete in <1s, took ${elapsed}ms`);
+            assert.strictEqual(scores.length, 1);
+        });
+    });
+    // ==========================================================================
+    // Timestamp Consistency
+    // ==========================================================================
+    describe('timestamp handling', () => {
+        it('uses provided timestamp in metadata', () => {
+            const metrics = computeSingleTurnMetrics({
+                task: 'Test',
+                response: 'Response',
+                toolCalls: [],
+            });
+            const customTimestamp = '2025-01-01T00:00:00.000Z';
+            const results = singleTurnMetricsToEvaluations(metrics, {
+                timestamp: customTimestamp,
+            });
+            for (const result of results) {
+                assert.strictEqual(result.timestamp, customTimestamp);
+            }
+        });
+        it('generates timestamp when not provided', () => {
+            const metrics = computeSingleTurnMetrics({
+                task: 'Test',
+                response: 'Response',
+                toolCalls: [],
+            });
+            const results = singleTurnMetricsToEvaluations(metrics, {});
+            for (const result of results) {
+                assert.ok(result.timestamp, 'Should have timestamp');
+                assert.ok(result.timestamp.includes('T'), 'Should be ISO format');
+            }
+        });
+    });
+});
+//# sourceMappingURL=agent-eval-metrics.test.js.map