observability-toolkit 1.8.5 → 2.1.0

package/dist/backends/index.test.js

@@ -1,9 +1,12 @@
 /**
  * Tests for backend index exports - OTel GenAI constants and types
  */
-import { describe, it } from 'node:test';
+import { describe, it } from 'vitest';
 import assert from 'node:assert';
-import { GENAI_PROVIDERS, SUPPORTED_PROVIDERS, GENAI_CORE_ATTRIBUTES, GENAI_AGENT_ATTRIBUTES, GENAI_TOOL_ATTRIBUTES, GENAI_REQUEST_ATTRIBUTES, GENAI_RESPONSE_ATTRIBUTES, GENAI_USAGE_ATTRIBUTES, GENAI_EVALUATION_ATTRIBUTES, } from './index.js';
+import { GENAI_PROVIDERS, SUPPORTED_PROVIDERS, GENAI_CORE_ATTRIBUTES, GENAI_AGENT_ATTRIBUTES, GENAI_TOOL_ATTRIBUTES, GENAI_REQUEST_ATTRIBUTES, GENAI_RESPONSE_ATTRIBUTES, GENAI_USAGE_ATTRIBUTES, GENAI_EVALUATION_ATTRIBUTES, SERVER_ATTRIBUTES, GENAI_CLIENT_METRICS, GENAI_SERVER_METRICS, GENAI_HISTOGRAM_BUCKETS, isIndexedStep, isNamedStep, traceSpanSchema, logRecordSchema, metricDataPointSchema, histogramDataPointSchema, llmEventSchema, evaluationResultSchema, stepScoreSchema, toolVerificationSchema, costDataPointSchema, datasetRecordSchema, datasetTraceRecordSchema, datasetRunRecordSchema, evaluatorTypeSchema, instrumentationScopeSchema, spanLinkSchema, } from './index.js';
+import { NUMERICAL_MIN_DENOMINATOR } from '../lib/quality/quality-constants.js';
+import { DEFAULT_LIMIT_10, EPOCH_SEC } from '../test-helpers/test-constants.js';
+import { testTraceId, testSpanId } from '../test-helpers/test-data-builders.js';
 describe('OTel GenAI Provider Constants', () => {
     describe('GENAI_PROVIDERS', () => {
         it('should include Anthropic provider', () => {
@@ -40,16 +43,7 @@ describe('OTel GenAI Provider Constants', () => {
     describe('SUPPORTED_PROVIDERS', () => {
         it('should be an array of all provider values', () => {
             assert.ok(Array.isArray(SUPPORTED_PROVIDERS));
-            assert.ok(SUPPORTED_PROVIDERS.length >= 10);
-        });
-        it('should contain anthropic', () => {
-            assert.ok(SUPPORTED_PROVIDERS.includes('anthropic'));
-        });
-        it('should contain openai', () => {
-            assert.ok(SUPPORTED_PROVIDERS.includes('openai'));
-        });
-        it('should contain gcp.gemini', () => {
-            assert.ok(SUPPORTED_PROVIDERS.includes('gcp.gemini'));
+            assert.ok(SUPPORTED_PROVIDERS.length >= DEFAULT_LIMIT_10);
         });
         it('should contain all GENAI_PROVIDERS values', () => {
             const providerValues = Object.values(GENAI_PROVIDERS);
@@ -61,21 +55,6 @@ describe('OTel GenAI Provider Constants', () => {
             assert.strictEqual(SUPPORTED_PROVIDERS.length, Object.keys(GENAI_PROVIDERS).length);
         });
     });
-    describe('GenAIProvider type', () => {
-        it('should accept valid provider values', () => {
-            const providers = [
-                'anthropic',
-                'openai',
-                'aws.bedrock',
-                'azure.ai.openai',
-                'gcp.gemini',
-                'gcp.vertex_ai',
-                'cohere',
-                'mistral_ai',
-            ];
-            assert.strictEqual(providers.length, 8);
-        });
-    });
 });
 describe('OTel GenAI Attribute Constants', () => {
     describe('GENAI_CORE_ATTRIBUTES', () => {
@@ -91,6 +70,9 @@ describe('OTel GenAI Attribute Constants', () => {
         it('should have CONVERSATION_ID', () => {
             assert.strictEqual(GENAI_CORE_ATTRIBUTES.CONVERSATION_ID, 'gen_ai.conversation.id');
         });
+        it('should have OUTPUT_TYPE', () => {
+            assert.strictEqual(GENAI_CORE_ATTRIBUTES.OUTPUT_TYPE, 'gen_ai.output.type');
+        });
     });
     describe('GENAI_AGENT_ATTRIBUTES', () => {
         it('should have AGENT_ID', () => {
@@ -99,6 +81,9 @@ describe('OTel GenAI Attribute Constants', () => {
         it('should have AGENT_NAME', () => {
             assert.strictEqual(GENAI_AGENT_ATTRIBUTES.AGENT_NAME, 'gen_ai.agent.name');
         });
+        it('should have AGENT_VERSION', () => {
+            assert.strictEqual(GENAI_AGENT_ATTRIBUTES.AGENT_VERSION, 'gen_ai.agent.version');
+        });
     });
     describe('GENAI_TOOL_ATTRIBUTES', () => {
         it('should have TOOL_NAME', () => {
@@ -107,6 +92,12 @@ describe('OTel GenAI Attribute Constants', () => {
         it('should have TOOL_CALL_ID', () => {
             assert.strictEqual(GENAI_TOOL_ATTRIBUTES.TOOL_CALL_ID, 'gen_ai.tool.call.id');
         });
+        it('should have TOOL_CALL_ARGUMENTS', () => {
+            assert.strictEqual(GENAI_TOOL_ATTRIBUTES.TOOL_CALL_ARGUMENTS, 'gen_ai.tool.call.arguments');
+        });
+        it('should have TOOL_CALL_RESULT', () => {
+            assert.strictEqual(GENAI_TOOL_ATTRIBUTES.TOOL_CALL_RESULT, 'gen_ai.tool.call.result');
+        });
     });
     describe('GENAI_REQUEST_ATTRIBUTES', () => {
         it('should have MODEL', () => {
@@ -118,6 +109,21 @@ describe('OTel GenAI Attribute Constants', () => {
         it('should have MAX_TOKENS', () => {
             assert.strictEqual(GENAI_REQUEST_ATTRIBUTES.MAX_TOKENS, 'gen_ai.request.max_tokens');
         });
+        it('should have TOP_P', () => {
+            assert.strictEqual(GENAI_REQUEST_ATTRIBUTES.TOP_P, 'gen_ai.request.top_p');
+        });
+        it('should have TOP_K', () => {
+            assert.strictEqual(GENAI_REQUEST_ATTRIBUTES.TOP_K, 'gen_ai.request.top_k');
+        });
+        it('should have STOP_SEQUENCES', () => {
+            assert.strictEqual(GENAI_REQUEST_ATTRIBUTES.STOP_SEQUENCES, 'gen_ai.request.stop_sequences');
+        });
+        it('should have FREQUENCY_PENALTY', () => {
+            assert.strictEqual(GENAI_REQUEST_ATTRIBUTES.FREQUENCY_PENALTY, 'gen_ai.request.frequency_penalty');
+        });
+        it('should have PRESENCE_PENALTY', () => {
+            assert.strictEqual(GENAI_REQUEST_ATTRIBUTES.PRESENCE_PENALTY, 'gen_ai.request.presence_penalty');
+        });
     });
     describe('GENAI_RESPONSE_ATTRIBUTES', () => {
         it('should have MODEL', () => {
@@ -126,6 +132,9 @@ describe('OTel GenAI Attribute Constants', () => {
         it('should have FINISH_REASONS', () => {
             assert.strictEqual(GENAI_RESPONSE_ATTRIBUTES.FINISH_REASONS, 'gen_ai.response.finish_reasons');
         });
+        it('should have ID', () => {
+            assert.strictEqual(GENAI_RESPONSE_ATTRIBUTES.ID, 'gen_ai.response.id');
+        });
     });
     describe('GENAI_USAGE_ATTRIBUTES', () => {
         it('should have INPUT_TOKENS', () => {
@@ -134,6 +143,20 @@ describe('OTel GenAI Attribute Constants', () => {
         it('should have OUTPUT_TOKENS', () => {
             assert.strictEqual(GENAI_USAGE_ATTRIBUTES.OUTPUT_TOKENS, 'gen_ai.usage.output_tokens');
         });
+        it('should have CACHE_READ_INPUT_TOKENS', () => {
+            assert.strictEqual(GENAI_USAGE_ATTRIBUTES.CACHE_READ_INPUT_TOKENS, 'gen_ai.usage.cache_read.input_tokens');
+        });
+        it('should have CACHE_CREATION_INPUT_TOKENS', () => {
+            assert.strictEqual(GENAI_USAGE_ATTRIBUTES.CACHE_CREATION_INPUT_TOKENS, 'gen_ai.usage.cache_creation.input_tokens');
+        });
+    });
+    describe('SERVER_ATTRIBUTES', () => {
+        it('should have ADDRESS', () => {
+            assert.strictEqual(SERVER_ATTRIBUTES.ADDRESS, 'server.address');
+        });
+        it('should have PORT', () => {
+            assert.strictEqual(SERVER_ATTRIBUTES.PORT, 'server.port');
+        });
     });
     describe('GENAI_EVALUATION_ATTRIBUTES', () => {
         it('should have NAME', () => {
@@ -147,10 +170,562 @@ describe('OTel GenAI Attribute Constants', () => {
         });
     });
 });
-describe('GenAIOperationName type', () => {
-    it('should accept valid operation names', () => {
-        const ops = ['chat', 'embeddings', 'invoke_agent', 'execute_tool'];
-        assert.strictEqual(ops.length, 4);
+describe('StepScore type guards', () => {
+    describe('isIndexedStep', () => {
+        it('should return true for numeric step', () => {
+            const score = { step: 0, score: 0.9 };
+            assert.strictEqual(isIndexedStep(score), true);
+        });
+        it('should return false for string step', () => {
+            const score = { step: 'final_response', score: 1.0 };
+            assert.strictEqual(isIndexedStep(score), false);
+        });
+    });
+    describe('isNamedStep', () => {
+        it('should return true for string step', () => {
+            const score = { step: 'reasoning', score: 0.85 };
+            assert.strictEqual(isNamedStep(score), true);
+        });
+        it('should return false for numeric step', () => {
+            const score = { step: 0, score: 0.9 };
+            assert.strictEqual(isNamedStep(score), false);
+        });
+    });
+    describe('mutual exclusivity', () => {
+        it('should have exactly one guard return true', () => {
+            const indexedScore = { step: 0, score: 0.9 };
+            const namedScore = { step: 'final', score: 1.0 };
+            assert.strictEqual(isIndexedStep(indexedScore) !== isNamedStep(indexedScore), true);
+            assert.strictEqual(isIndexedStep(namedScore) !== isNamedStep(namedScore), true);
+        });
+    });
+    describe('edge cases with NaN/null (guards are not validators)', () => {
+        it('should treat NaN step as indexed (typeof NaN === "number")', () => {
+            // NaN is typeof "number" in JavaScript — guards check type, not validity
+            const score = { step: NaN, score: 0.5 };
+            assert.strictEqual(isIndexedStep(score), true);
+            assert.strictEqual(isNamedStep(score), false);
+        });
+        it('should treat null step as neither indexed nor named', () => {
+            // null is typeof "object" — neither string nor number
+            const score = { step: null, score: 0.5 };
+            assert.strictEqual(isIndexedStep(score), false);
+            assert.strictEqual(isNamedStep(score), false);
+        });
+        it('should treat undefined step as neither indexed nor named', () => {
+            const score = { step: undefined, score: 0.5 };
+            assert.strictEqual(isIndexedStep(score), false);
+            assert.strictEqual(isNamedStep(score), false);
+        });
+    });
+});
+describe('OTel GenAI Metric Constants', () => {
+    describe('GENAI_CLIENT_METRICS', () => {
+        it('should include token usage metric', () => {
+            assert.strictEqual(GENAI_CLIENT_METRICS.TOKEN_USAGE, 'gen_ai.client.token.usage');
+        });
+        it('should include operation duration metric', () => {
+            assert.strictEqual(GENAI_CLIENT_METRICS.OPERATION_DURATION, 'gen_ai.client.operation.duration');
+        });
+        it('should include cost metric', () => {
+            assert.strictEqual(GENAI_CLIENT_METRICS.COST, 'gen_ai.client.cost');
+        });
+    });
+    describe('GENAI_SERVER_METRICS', () => {
+        it('should include request duration metric', () => {
+            assert.strictEqual(GENAI_SERVER_METRICS.REQUEST_DURATION, 'gen_ai.server.request.duration');
+        });
+        it('should include TTFT metric', () => {
+            assert.strictEqual(GENAI_SERVER_METRICS.TIME_TO_FIRST_TOKEN, 'gen_ai.server.time_to_first_token');
+        });
+        it('should include TPOT metric', () => {
+            assert.strictEqual(GENAI_SERVER_METRICS.TIME_PER_OUTPUT_TOKEN, 'gen_ai.server.time_per_output_token');
+        });
+    });
+    describe('GENAI_HISTOGRAM_BUCKETS', () => {
+        it('should have TOKEN_USAGE buckets in ascending order', () => {
+            const buckets = [...GENAI_HISTOGRAM_BUCKETS.TOKEN_USAGE];
+            for (let i = 1; i < buckets.length; i++) {
+                assert.ok(buckets[i] > buckets[i - 1], `Bucket ${buckets[i]} should be > ${buckets[i - 1]}`);
+            }
+        });
+        it('should have OPERATION_DURATION buckets in ascending order', () => {
+            const buckets = [...GENAI_HISTOGRAM_BUCKETS.OPERATION_DURATION];
+            for (let i = 1; i < buckets.length; i++) {
+                assert.ok(buckets[i] > buckets[i - 1], `Bucket ${buckets[i]} should be > ${buckets[i - 1]}`);
+            }
+        });
+        it('should have SERVER_TIMING buckets in ascending order', () => {
+            const buckets = [...GENAI_HISTOGRAM_BUCKETS.SERVER_TIMING];
+            for (let i = 1; i < buckets.length; i++) {
+                assert.ok(buckets[i] > buckets[i - 1], `Bucket ${buckets[i]} should be > ${buckets[i - 1]}`);
+            }
+        });
+        it('should have COST_USD buckets in ascending order', () => {
+            const buckets = [...GENAI_HISTOGRAM_BUCKETS.COST_USD];
+            for (let i = 1; i < buckets.length; i++) {
+                assert.ok(buckets[i] > buckets[i - 1], `Bucket ${buckets[i]} should be > ${buckets[i - 1]}`);
+            }
+        });
+        it('should have COST_USD starting below $0.001', () => {
+            assert.ok(GENAI_HISTOGRAM_BUCKETS.COST_USD[0] < NUMERICAL_MIN_DENOMINATOR);
+        });
+        it('should have COST_USD covering up to $10', () => {
+            const last = GENAI_HISTOGRAM_BUCKETS.COST_USD[GENAI_HISTOGRAM_BUCKETS.COST_USD.length - 1];
+            assert.strictEqual(last, DEFAULT_LIMIT_10);
+        });
+    });
+});
+// ============================================================================
+// Zod Schema Validation Tests
+// ============================================================================
+const NANO_START = EPOCH_SEC * 1_000_000_000;
+const SCORE_HIGH = 0.9;
+const SCORE_MID = 0.7;
+const SCORE_FULL = 1.0;
+const HISTOGRAM_COUNT = 5;
+const TOKEN_COUNT = 150;
+const TOKEN_OUTPUT = 50;
+const TOKEN_TOTAL = 200;
+const COST_USD = 0.003;
+const TRACE_COUNT = 42;
+const RESULT_COUNT = 10;
+const DATASET_VERSION = 3;
+describe('Backend Zod Schemas', () => {
+    describe('instrumentationScopeSchema', () => {
+        it('should accept valid scope', () => {
+            const result = instrumentationScopeSchema.safeParse({
+                name: '@opentelemetry/sdk-trace-node',
+                version: '1.0.0',
+                schemaUrl: 'https://opentelemetry.io/schemas/1.0.0',
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should accept scope with only name', () => {
+            const result = instrumentationScopeSchema.safeParse({ name: 'my-lib' });
+            assert.strictEqual(result.success, true);
+        });
+        it('should reject missing name', () => {
+            const result = instrumentationScopeSchema.safeParse({ version: '1.0' });
+            assert.strictEqual(result.success, false);
+        });
+    });
+    describe('spanLinkSchema', () => {
+        it('should accept valid link', () => {
+            const result = spanLinkSchema.safeParse({
+                traceId: testTraceId(1),
+                spanId: testSpanId(1),
+                attributes: { 'link.type': 'parent' },
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should reject missing spanId', () => {
+            const result = spanLinkSchema.safeParse({ traceId: testTraceId(1) });
+            assert.strictEqual(result.success, false);
+        });
+    });
+    describe('traceSpanSchema', () => {
+        const validSpan = {
+            traceId: testTraceId(1),
+            spanId: testSpanId(1),
+            name: 'HTTP GET /api',
+            startTimeUnixNano: NANO_START,
+        };
+        it('should accept minimal valid span', () => {
+            const result = traceSpanSchema.safeParse(validSpan);
+            assert.strictEqual(result.success, true);
+        });
+        it('should accept span with all optional fields', () => {
+            const result = traceSpanSchema.safeParse({
+                ...validSpan,
+                parentSpanId: testSpanId(2),
+                kind: 'SERVER',
+                endTimeUnixNano: NANO_START + 1_000_000,
+                durationMs: 1,
+                status: { code: 1, message: 'OK' },
+                statusCode: 'OK',
+                attributes: { 'http.method': 'GET' },
+                events: [{ name: 'exception', timestamp: NANO_START, attributes: { msg: 'err' } }],
+                links: [{ traceId: testTraceId(2), spanId: testSpanId(3) }],
+                instrumentationScope: { name: 'my-lib' },
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should reject invalid statusCode', () => {
+            const result = traceSpanSchema.safeParse({
+                ...validSpan,
+                statusCode: 'INVALID',
+            });
+            assert.strictEqual(result.success, false);
+        });
+        it('should reject missing traceId', () => {
+            const { traceId: _, ...noTraceId } = validSpan;
+            const result = traceSpanSchema.safeParse(noTraceId);
+            assert.strictEqual(result.success, false);
+        });
+        it('should reject missing name', () => {
+            const { name: _, ...noName } = validSpan;
+            const result = traceSpanSchema.safeParse(noName);
+            assert.strictEqual(result.success, false);
+        });
+    });
+    describe('logRecordSchema', () => {
+        const validLog = {
+            timestamp: '2026-01-01T00:00:00Z',
+            severity: 'INFO',
+            body: 'Request processed',
+        };
+        it('should accept minimal valid log', () => {
+            const result = logRecordSchema.safeParse(validLog);
+            assert.strictEqual(result.success, true);
+        });
+        it('should accept log with optional fields', () => {
+            const result = logRecordSchema.safeParse({
+                ...validLog,
+                severityNumber: 9,
+                traceId: testTraceId(3),
+                spanId: testSpanId(4),
+                attributes: { 'service.name': 'api' },
+                instrumentationScope: { name: 'pino' },
+                extractedFields: { userId: '123' },
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should reject missing body', () => {
+            const { body: _, ...noBody } = validLog;
+            const result = logRecordSchema.safeParse(noBody);
+            assert.strictEqual(result.success, false);
+        });
+    });
+    describe('metricDataPointSchema', () => {
+        it('should accept minimal valid metric', () => {
+            const result = metricDataPointSchema.safeParse({
+                timestamp: '2026-01-01T00:00:00Z',
+                name: 'http.request.duration',
+                value: 42,
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should accept metric with histogram and exemplars', () => {
+            const result = metricDataPointSchema.safeParse({
+                timestamp: '2026-01-01T00:00:00Z',
+                name: 'gen_ai.client.token.usage',
+                value: TOKEN_COUNT,
+                unit: 'tokens',
+                histogram: { buckets: [{ le: 100, count: 3 }], sum: TOKEN_COUNT, count: HISTOGRAM_COUNT },
+                exemplars: [{ timestamp: '2026-01-01T00:00:00Z', value: 42, traceId: testTraceId(5) }],
+                aggregationTemporality: 'CUMULATIVE',
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should reject invalid aggregationTemporality', () => {
+            const result = metricDataPointSchema.safeParse({
+                timestamp: '2026-01-01T00:00:00Z',
+                name: 'metric',
+                value: 1,
+                aggregationTemporality: 'INVALID',
+            });
+            assert.strictEqual(result.success, false);
+        });
+    });
+    describe('histogramDataPointSchema', () => {
+        it('should accept valid histogram data point', () => {
+            const result = histogramDataPointSchema.safeParse({
+                id: 1,
+                name: 'gen_ai.client.operation.duration',
+                count: HISTOGRAM_COUNT,
+                sum: 2.5,
+                min: 0.1,
+                max: 1.2,
+                aggregationTemporality: 2,
+                explicitBounds: [0.1, 0.5, 1.0],
+                bucketCounts: [1, 2, 1, 1],
+                timestamp: '2026-01-01T00:00:00Z',
+                serviceName: 'api',
+                sessionId: 'sess-1',
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should accept nullable sum/min/max/serviceName/sessionId', () => {
+            const result = histogramDataPointSchema.safeParse({
+                id: 1,
+                name: 'metric',
+                count: 0,
+                sum: null,
+                min: null,
+                max: null,
+                aggregationTemporality: 0,
+                explicitBounds: [],
+                bucketCounts: [0],
+                timestamp: '2026-01-01T00:00:00Z',
+                serviceName: null,
+                sessionId: null,
+            });
+            assert.strictEqual(result.success, true);
+        });
+    });
+    describe('llmEventSchema', () => {
+        it('should accept valid LLM event', () => {
+            const result = llmEventSchema.safeParse({
+                timestamp: '2026-01-01T00:00:00Z',
+                name: 'gen_ai.chat',
+                attributes: { 'gen_ai.request.model': 'claude-sonnet-4-6' },
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should reject missing attributes', () => {
+            const result = llmEventSchema.safeParse({
+                timestamp: '2026-01-01T00:00:00Z',
+                name: 'gen_ai.chat',
+            });
+            assert.strictEqual(result.success, false);
+        });
+    });
+    describe('stepScoreSchema', () => {
+        it('should accept numeric step', () => {
+            const result = stepScoreSchema.safeParse({ step: 0, score: SCORE_HIGH });
+            assert.strictEqual(result.success, true);
+        });
+        it('should accept string step with evidence', () => {
+            const result = stepScoreSchema.safeParse({
+                step: 'final_response',
+                score: SCORE_FULL,
+                evidence: { matched: true },
+                explanation: 'Correct output',
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should accept null evidence', () => {
+            const result = stepScoreSchema.safeParse({ step: 0, score: SCORE_MID, evidence: null });
+            assert.strictEqual(result.success, true);
+        });
+        it('should accept string evidence', () => {
+            const result = stepScoreSchema.safeParse({ step: 0, score: SCORE_MID, evidence: 'reason' });
+            assert.strictEqual(result.success, true);
+        });
+        it('should reject score > 1', () => {
+            const result = stepScoreSchema.safeParse({ step: 0, score: 1.5 });
+            assert.strictEqual(result.success, false);
+        });
+        it('should reject score < 0', () => {
+            const result = stepScoreSchema.safeParse({ step: 0, score: -0.1 });
+            assert.strictEqual(result.success, false);
+        });
+    });
+    describe('toolVerificationSchema', () => {
+        it('should accept valid verification', () => {
+            const result = toolVerificationSchema.safeParse({
+                toolName: 'search',
+                toolCorrect: true,
+                argsCorrect: true,
+                score: SCORE_FULL,
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should accept full verification with all fields', () => {
+            const result = toolVerificationSchema.safeParse({
+                toolName: 'search',
+                toolCallId: 'call_abc123',
+                toolCorrect: true,
+                argsCorrect: true,
+                resultCorrect: true,
+                score: SCORE_FULL,
+                expectedTool: 'search',
+                evidence: { query: 'test', results: HISTOGRAM_COUNT },
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should reject score > 1', () => {
+            const result = toolVerificationSchema.safeParse({
+                toolName: 'search',
+                toolCorrect: true,
+                argsCorrect: true,
+                score: 1.1,
+            });
+            assert.strictEqual(result.success, false);
+        });
+        it('should reject missing toolCorrect', () => {
+            const result = toolVerificationSchema.safeParse({
+                toolName: 'search',
+                argsCorrect: true,
+                score: SCORE_FULL,
+            });
+            assert.strictEqual(result.success, false);
+        });
+    });
+    describe('evaluatorTypeSchema', () => {
+        it('should accept all valid evaluator types', () => {
+            for (const t of ['llm', 'human', 'rule', 'classifier', 'seed', 'canary']) {
+                assert.strictEqual(evaluatorTypeSchema.safeParse(t).success, true);
+            }
+        });
+        it('should reject invalid type', () => {
+            assert.strictEqual(evaluatorTypeSchema.safeParse('other').success, false);
+        });
+    });
+    describe('evaluationResultSchema', () => {
+        it('should accept minimal valid result', () => {
+            const result = evaluationResultSchema.safeParse({
+                timestamp: '2026-01-01T00:00:00Z',
+                evaluationName: 'relevance',
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should accept full result with agent-as-judge fields', () => {
+            const result = evaluationResultSchema.safeParse({
+                timestamp: '2026-01-01T00:00:00Z',
+                evaluationName: 'trajectory_quality',
+                scoreValue: SCORE_HIGH,
+                scoreLabel: 'pass',
+                scoreUnit: 'ratio_0_1',
+                explanation: 'Good trajectory',
+                evaluator: 'claude-sonnet-4-6',
+                evaluatorType: 'llm',
+                responseId: 'resp-1',
+                traceId: testTraceId(6),
+                spanId: testSpanId(7),
+                sessionId: 'sess-1',
+                agentId: 'agent-1',
+                agentName: 'researcher',
+                stepScores: [
+                    { step: 0, score: SCORE_HIGH, explanation: 'Good' },
+                    { step: 'final', score: SCORE_FULL },
+                ],
+                toolVerifications: [
+                    { toolName: 'search', toolCorrect: true, argsCorrect: true, score: SCORE_FULL },
+                ],
+                trajectoryLength: 2,
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should reject invalid evaluatorType', () => {
+            const result = evaluationResultSchema.safeParse({
+                timestamp: '2026-01-01T00:00:00Z',
+                evaluationName: 'relevance',
+                evaluatorType: 'invalid',
+            });
+            assert.strictEqual(result.success, false);
+        });
+    });
+    describe('costDataPointSchema', () => {
+        it('should accept valid cost data', () => {
+            const result = costDataPointSchema.safeParse({
+                model: 'claude-sonnet-4-6',
+                inputTokens: TOKEN_COUNT,
+                outputTokens: TOKEN_OUTPUT,
+                totalTokens: TOKEN_TOTAL,
+                estimatedUsd: COST_USD,
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should accept null model', () => {
+            const result = costDataPointSchema.safeParse({
+                model: null,
+                inputTokens: 0,
+                outputTokens: 0,
+                totalTokens: 0,
+                estimatedUsd: 0,
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should reject missing inputTokens', () => {
+            const result = costDataPointSchema.safeParse({
+                model: 'gpt-4',
+                outputTokens: 0,
+                totalTokens: 0,
+                estimatedUsd: 0,
+            });
+            assert.strictEqual(result.success, false);
+        });
+    });
+    describe('datasetRecordSchema', () => {
+        const validDataset = {
+            id: 'ds-1',
+            name: 'test-dataset',
+            description: null,
+            createdAt: '2026-01-01T00:00:00Z',
+            frozen: 0,
+            traceCount: TRACE_COUNT,
+            evaluationNames: ['relevance', 'faithfulness'],
+            dateRangeStart: '2026-01-01',
+            dateRangeEnd: '2026-01-31',
+            selectionCriteria: null,
+        };
+        it('should accept minimal valid dataset', () => {
+            const result = datasetRecordSchema.safeParse(validDataset);
+            assert.strictEqual(result.success, true);
+        });
+        it('should accept dataset with versioning fields', () => {
+            const result = datasetRecordSchema.safeParse({
+                ...validDataset,
+                version: DATASET_VERSION,
+                parentVersion: 2,
+                versionCreatedAt: '2026-01-15T00:00:00Z',
+                versionReason: 'traces_added',
+                fieldMapping: { input: 'user.query', expectedOutput: 'expected.answer' },
+                traceSnapshot: ['trace-1', 'trace-2'],
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should reject invalid versionReason', () => {
+            const result = datasetRecordSchema.safeParse({
+                ...validDataset,
+                versionReason: 'invalid_reason',
+            });
+            assert.strictEqual(result.success, false);
+        });
+    });
+    describe('datasetTraceRecordSchema', () => {
+        it('should accept valid trace record', () => {
+            const result = datasetTraceRecordSchema.safeParse({
+                datasetId: 'ds-1',
+                traceId: testTraceId(8),
+                addedAt: '2026-01-01T00:00:00Z',
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should reject missing traceId', () => {
+            const result = datasetTraceRecordSchema.safeParse({
+                datasetId: 'ds-1',
+                addedAt: '2026-01-01T00:00:00Z',
+            });
+            assert.strictEqual(result.success, false);
+        });
+    });
+    describe('datasetRunRecordSchema', () => {
+        it('should accept valid run record', () => {
+            const result = datasetRunRecordSchema.safeParse({
+                id: 'run-1',
+                datasetId: 'ds-1',
+                datasetVersion: DATASET_VERSION,
+                runAt: '2026-01-01T00:00:00Z',
+                evaluationNames: ['relevance'],
+                resultCount: RESULT_COUNT,
+                evaluator: 'judge-evaluations',
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should accept run without optional evaluator', () => {
+            const result = datasetRunRecordSchema.safeParse({
+                id: 'run-1',
+                datasetId: 'ds-1',
+                datasetVersion: 1,
+                runAt: '2026-01-01T00:00:00Z',
+                evaluationNames: [],
+                resultCount: 0,
+            });
+            assert.strictEqual(result.success, true);
+        });
+        it('should reject missing datasetVersion', () => {
+            const result = datasetRunRecordSchema.safeParse({
+                id: 'run-1',
+                datasetId: 'ds-1',
+                runAt: '2026-01-01T00:00:00Z',
+                evaluationNames: [],
+                resultCount: 0,
+            });
+            assert.strictEqual(result.success, false);
+        });
     });
 });
 //# sourceMappingURL=index.test.js.map