observability-toolkit 2.0.0 → 2.1.0

package/dist/lib/confident-export.test.js

@@ -1,835 +0,0 @@
-/**
- * Tests for confident-export.ts
- *
- * Covers config validation, auth header creation, OTLP conversion, and batching.
- */
-import { describe, it, beforeEach, afterEach, mock } from 'node:test';
-import assert from 'node:assert';
-import { validateConfidentUrl, validateConfidentConfig, createConfidentAuthHeader, evaluationsToConfidentTraces, exportToConfident, } from './confident-export.js';
-import { HttpStatus } from './constants.js';
-describe('confident-export', () => {
-    describe('validateConfidentUrl', () => {
-        describe('valid URLs', () => {
-            it('accepts valid HTTPS URL', () => {
-                const url = 'https://otel.confident-ai.com';
-                assert.strictEqual(validateConfidentUrl(url), 'https://otel.confident-ai.com');
-            });
-            it('accepts HTTPS URL with port', () => {
-                const url = 'https://confident.example.com:8443';
-                assert.strictEqual(validateConfidentUrl(url), 'https://confident.example.com:8443');
-            });
-            it('preserves path for custom endpoints', () => {
-                const url = 'https://example.com/otel';
-                assert.strictEqual(validateConfidentUrl(url), 'https://example.com/otel');
-            });
-            it('preserves API path prefix', () => {
-                const url = 'https://otel.confident-ai.com/api/v1/traces';
-                assert.strictEqual(validateConfidentUrl(url), 'https://otel.confident-ai.com/api/v1/traces');
-            });
-            it('strips trailing slash from path', () => {
-                const url = 'https://example.com/otel/';
-                assert.strictEqual(validateConfidentUrl(url), 'https://example.com/otel');
-            });
-            it('strips query params from URL', () => {
-                const url = 'https://otel.confident-ai.com?key=value';
-                assert.strictEqual(validateConfidentUrl(url), 'https://otel.confident-ai.com');
-            });
-        });
-        describe('SSRF protection - rejects localhost', () => {
-            it('rejects localhost', () => {
-                assert.strictEqual(validateConfidentUrl('https://localhost'), '');
-            });
-            it('rejects 127.0.0.1', () => {
-                assert.strictEqual(validateConfidentUrl('https://127.0.0.1'), '');
-            });
-            it('rejects 127.x.x.x variants', () => {
-                assert.strictEqual(validateConfidentUrl('https://127.100.200.1'), '');
-            });
-            it('rejects ::1 IPv6 localhost', () => {
-                assert.strictEqual(validateConfidentUrl('https://[::1]'), '');
-            });
-            it('rejects 0.0.0.0', () => {
-                assert.strictEqual(validateConfidentUrl('https://0.0.0.0'), '');
-            });
-            it('rejects .localhost TLD', () => {
-                assert.strictEqual(validateConfidentUrl('https://app.localhost'), '');
-            });
-        });
-        describe('SSRF protection - rejects cloud metadata', () => {
-            it('rejects AWS/GCP/Azure metadata IP', () => {
-                assert.strictEqual(validateConfidentUrl('https://169.254.169.254'), '');
-            });
-            it('rejects link-local range', () => {
-                assert.strictEqual(validateConfidentUrl('https://169.254.0.1'), '');
-            });
-        });
-        describe('SSRF protection - rejects private networks', () => {
-            it('rejects 10.x.x.x', () => {
-                assert.strictEqual(validateConfidentUrl('https://10.0.0.1'), '');
-            });
-            it('rejects 192.168.x.x', () => {
-                assert.strictEqual(validateConfidentUrl('https://192.168.1.1'), '');
-            });
-            it('rejects 172.16-31.x.x', () => {
-                assert.strictEqual(validateConfidentUrl('https://172.16.0.1'), '');
-                assert.strictEqual(validateConfidentUrl('https://172.31.255.255'), '');
-            });
-            it('rejects fc/fd IPv6 ULA', () => {
-                assert.strictEqual(validateConfidentUrl('https://[fc00::1]'), '');
-                assert.strictEqual(validateConfidentUrl('https://[fd00::1]'), '');
-            });
-            it('rejects fe80 IPv6 link-local', () => {
-                assert.strictEqual(validateConfidentUrl('https://[fe80::1]'), '');
-            });
-        });
-        describe('SSRF protection - rejects reserved domains', () => {
-            it('rejects .local TLD', () => {
-                assert.strictEqual(validateConfidentUrl('https://server.local'), '');
-            });
-            it('rejects .internal TLD', () => {
-                assert.strictEqual(validateConfidentUrl('https://api.internal'), '');
-            });
-            it('rejects .localdomain TLD', () => {
-                assert.strictEqual(validateConfidentUrl('https://host.localdomain'), '');
-            });
-            it('rejects .home.arpa TLD', () => {
-                assert.strictEqual(validateConfidentUrl('https://server.home.arpa'), '');
-            });
-        });
-        describe('SSRF protection - rejects HTTP', () => {
-            it('rejects HTTP protocol', () => {
-                assert.strictEqual(validateConfidentUrl('http://otel.confident-ai.com'), '');
-            });
-            it('rejects file protocol', () => {
-                assert.strictEqual(validateConfidentUrl('file:///etc/passwd'), '');
-            });
-        });
-        describe('edge cases', () => {
-            it('returns empty for empty string', () => {
-                assert.strictEqual(validateConfidentUrl(''), '');
-            });
-            it('returns empty for invalid URL', () => {
-                assert.strictEqual(validateConfidentUrl('not-a-url'), '');
-            });
-        });
-    });
-    describe('validateConfidentConfig', () => {
-        const originalEnv = { ...process.env };
-        beforeEach(() => {
-            delete process.env.CONFIDENT_ENDPOINT;
-            delete process.env.CONFIDENT_API_KEY;
-            delete process.env.CONFIDENT_BATCH_SIZE;
-            delete process.env.CONFIDENT_TIMEOUT_MS;
-            delete process.env.CONFIDENT_ENVIRONMENT;
-        });
-        afterEach(() => {
-            Object.assign(process.env, originalEnv);
-        });
-        it('uses default endpoint when not configured', () => {
-            const config = validateConfidentConfig({
-                apiKey: 'confident_us1234567890abcdefghij',
-            });
-            assert.strictEqual(config.endpoint, 'https://otel.confident-ai.com');
-        });
-        it('throws when endpoint is invalid', () => {
-            assert.throws(() => validateConfidentConfig({
-                endpoint: 'http://localhost',
-                apiKey: 'confident_us1234567890abcdefghij',
-            }), /endpoint not configured or invalid/);
-        });
-        it('throws when API key not configured', () => {
-            assert.throws(() => validateConfidentConfig({ endpoint: 'https://otel.confident-ai.com' }), /API key not configured/);
-        });
-        it('throws when API key has invalid format', () => {
-            assert.throws(() => validateConfidentConfig({
-                endpoint: 'https://otel.confident-ai.com',
-                apiKey: 'invalid-key',
-            }), /Invalid Confident AI API key format/);
-        });
-        it('throws when API key is too short', () => {
-            assert.throws(() => validateConfidentConfig({
-                endpoint: 'https://otel.confident-ai.com',
-                apiKey: 'confident_usX', // Too short
-            }), /Invalid Confident AI API key format/);
-        });
-        it('accepts valid API key format', () => {
-            const config = validateConfidentConfig({
-                endpoint: 'https://otel.confident-ai.com',
-                apiKey: 'confident_us1234567890abcdefghij',
-            });
-            assert.strictEqual(config.apiKey, 'confident_us1234567890abcdefghij');
-        });
-        it('returns valid config with all required fields', () => {
-            const config = validateConfidentConfig({
-                endpoint: 'https://otel.confident-ai.com',
-                apiKey: 'confident_us1234567890abcdefghij',
-            });
-            assert.strictEqual(config.endpoint, 'https://otel.confident-ai.com');
-            assert.strictEqual(config.apiKey, 'confident_us1234567890abcdefghij');
-            assert.strictEqual(config.batchSize, 100); // default
-            assert.strictEqual(config.timeoutMs, 30000); // default
-            assert.strictEqual(config.environment, 'development'); // default
-        });
-        it('uses custom batch size', () => {
-            const config = validateConfidentConfig({
-                apiKey: 'confident_us1234567890abcdefghij',
-                batchSize: 50,
-            });
-            assert.strictEqual(config.batchSize, 50);
-        });
-        it('throws when batch size too small', () => {
-            assert.throws(() => validateConfidentConfig({
-                apiKey: 'confident_us1234567890abcdefghij',
-                batchSize: 0,
-            }), /batch size must be between/);
-        });
-        it('throws when batch size too large', () => {
-            assert.throws(() => validateConfidentConfig({
-                apiKey: 'confident_us1234567890abcdefghij',
-                batchSize: 1001,
-            }), /batch size must be between/);
-        });
-        it('throws when timeout too small', () => {
-            assert.throws(() => validateConfidentConfig({
-                apiKey: 'confident_us1234567890abcdefghij',
-                timeoutMs: 500,
-            }), /timeout must be between/);
-        });
-        it('throws when timeout too large', () => {
-            assert.throws(() => validateConfidentConfig({
-                apiKey: 'confident_us1234567890abcdefghij',
-                timeoutMs: 200000,
-            }), /timeout must be between/);
-        });
-        it('accepts valid environment values', () => {
-            for (const env of ['production', 'development', 'staging', 'testing']) {
-                const config = validateConfidentConfig({
-                    apiKey: 'confident_us1234567890abcdefghij',
-                    environment: env,
-                });
-                assert.strictEqual(config.environment, env);
-            }
-        });
-        it('throws for invalid environment', () => {
-            assert.throws(() => validateConfidentConfig({
-                apiKey: 'confident_us1234567890abcdefghij',
-                environment: 'invalid',
-            }), /Invalid environment/);
-        });
-        it('accepts metric collection', () => {
-            const config = validateConfidentConfig({
-                apiKey: 'confident_us1234567890abcdefghij',
-                metricCollection: 'my-collection',
-            });
-            assert.strictEqual(config.metricCollection, 'my-collection');
-        });
-    });
-    describe('createConfidentAuthHeader', () => {
-        it('returns API key directly', () => {
-            const header = createConfidentAuthHeader('confident_us1234567890abcdefghij');
-            assert.strictEqual(header, 'confident_us1234567890abcdefghij');
-        });
-        it('handles API keys with special characters', () => {
-            const header = createConfidentAuthHeader('confident_us1234567890_test-key');
-            assert.strictEqual(header, 'confident_us1234567890_test-key');
-        });
-    });
-    describe('evaluationsToConfidentTraces', () => {
-        const baseConfig = {
-            endpoint: 'https://otel.confident-ai.com',
-            apiKey: 'confident_us1234567890abcdefghij',
-            batchSize: 100,
-            timeoutMs: 30000,
-            environment: 'development',
-        };
-        const baseEvaluation = {
-            timestamp: '2024-01-15T10:00:00Z',
-            evaluationName: 'relevance',
-            scoreValue: 0.85,
-            scoreLabel: 'good',
-            scoreUnit: 'ratio_0_1',
-            explanation: 'The response was relevant',
-            evaluator: 'gpt-4',
-            evaluatorType: 'llm',
-            responseId: 'resp-123',
-            traceId: 'abc123def456',
-            sessionId: 'session-1',
-        };
-        it('converts single evaluation to OTLP trace', () => {
-            const result = evaluationsToConfidentTraces([baseEvaluation], baseConfig);
-            assert.strictEqual(result.resourceSpans.length, 1);
-            assert.strictEqual(result.resourceSpans[0].scopeSpans.length, 1);
-            assert.strictEqual(result.resourceSpans[0].scopeSpans[0].spans.length, 1);
-            const span = result.resourceSpans[0].scopeSpans[0].spans[0];
-            assert.strictEqual(span.traceId, 'abc123def456');
-            assert.strictEqual(span.name, 'evaluation_export');
-            assert.ok(span.events);
-            assert.strictEqual(span.events.length, 1);
-            const event = span.events[0];
-            assert.strictEqual(event.name, 'gen_ai.evaluation.result');
-            assert.ok(event.attributes);
-            // Check GenAI evaluation attributes
-            const attrs = Object.fromEntries(event.attributes.map(a => [a.key, a.value.stringValue ?? a.value.doubleValue]));
-            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'], 'good');
-            assert.strictEqual(attrs['gen_ai.evaluation.explanation'], 'The response was relevant');
-        });
-        it('includes Confident AI-specific attributes', () => {
-            const result = evaluationsToConfidentTraces([baseEvaluation], baseConfig);
-            const event = result.resourceSpans[0].scopeSpans[0].spans[0].events?.[0];
-            const attrs = Object.fromEntries(event.attributes.map(a => [a.key, a.value.stringValue]));
-            assert.strictEqual(attrs['confident.span.type'], 'custom');
-            assert.strictEqual(attrs['confident.span.name'], 'relevance');
-            assert.ok(attrs['confident.span.metadata']);
-            // Verify metadata JSON
-            const metadata = JSON.parse(attrs['confident.span.metadata']);
-            assert.strictEqual(metadata.evaluationName, 'relevance');
-            assert.strictEqual(metadata.scoreValue, 0.85);
-        });
-        it('includes thread_id for conversation tracking', () => {
-            const result = evaluationsToConfidentTraces([baseEvaluation], baseConfig);
-            const spanAttrs = result.resourceSpans[0].scopeSpans[0].spans[0].attributes;
-            const threadIdAttr = spanAttrs?.find(a => a.key === 'confident.trace.thread_id');
-            assert.ok(threadIdAttr);
-            assert.strictEqual(threadIdAttr.value.stringValue, 'session-1');
-        });
-        it('includes environment in resource attributes', () => {
-            const result = evaluationsToConfidentTraces([baseEvaluation], baseConfig);
-            const resourceAttrs = result.resourceSpans[0].resource.attributes;
-            const envAttr = resourceAttrs.find(a => a.key === 'confident.trace.environment');
-            assert.ok(envAttr);
-            assert.strictEqual(envAttr.value.stringValue, 'development');
-        });
-        it('includes metric collection when specified', () => {
-            const configWithMetric = { ...baseConfig, metricCollection: 'accuracy-tests' };
-            const result = evaluationsToConfidentTraces([baseEvaluation], configWithMetric);
-            const spanAttrs = result.resourceSpans[0].scopeSpans[0].spans[0].attributes;
-            const metricAttr = spanAttrs?.find(a => a.key === 'confident.span.metric_collection');
-            assert.ok(metricAttr);
-            assert.strictEqual(metricAttr.value.stringValue, 'accuracy-tests');
-        });
-        it('includes trace tags with traceId', () => {
-            const result = evaluationsToConfidentTraces([baseEvaluation], baseConfig);
-            const spanAttrs = result.resourceSpans[0].scopeSpans[0].spans[0].attributes;
-            const tagsAttr = spanAttrs?.find(a => a.key === 'confident.trace.tags');
-            assert.ok(tagsAttr);
-            assert.ok(tagsAttr.value.arrayValue);
-            assert.strictEqual(tagsAttr.value.arrayValue.values[0].stringValue, 'abc123def456');
-        });
-        it('groups multiple evaluations by traceId', () => {
-            const evaluations = [
-                { ...baseEvaluation, traceId: 'trace-1' },
-                { ...baseEvaluation, traceId: 'trace-1', evaluationName: 'quality' },
-                { ...baseEvaluation, traceId: 'trace-2' },
-            ];
-            const result = evaluationsToConfidentTraces(evaluations, baseConfig);
-            // Should have 2 spans (one per traceId)
-            const spans = result.resourceSpans[0].scopeSpans[0].spans;
-            assert.strictEqual(spans.length, 2);
-            // Find the trace-1 span
-            const trace1Span = spans.find(s => s.traceId === 'trace-1');
-            assert.ok(trace1Span);
-            assert.strictEqual(trace1Span.events?.length, 2);
-            // Find the trace-2 span
-            const trace2Span = spans.find(s => s.traceId === 'trace-2');
-            assert.ok(trace2Span);
-            assert.strictEqual(trace2Span.events?.length, 1);
-        });
-        it('generates traceId when not provided', () => {
-            const evaluation = { ...baseEvaluation };
-            delete evaluation.traceId;
-            const result = evaluationsToConfidentTraces([evaluation], baseConfig);
-            const span = result.resourceSpans[0].scopeSpans[0].spans[0];
-            assert.ok(span.traceId);
-            assert.strictEqual(span.traceId.length, 32);
-        });
-        it('handles evaluations with missing optional fields', () => {
-            const minimalEvaluation = {
-                timestamp: '2024-01-15T10:00:00Z',
-                evaluationName: 'test',
-            };
-            const result = evaluationsToConfidentTraces([minimalEvaluation], baseConfig);
-            const event = result.resourceSpans[0].scopeSpans[0].spans[0].events?.[0];
-            assert.ok(event);
-            assert.strictEqual(event.name, 'gen_ai.evaluation.result');
-            const evalNameAttr = event.attributes?.find(a => a.key === 'gen_ai.evaluation.name');
-            assert.ok(evalNameAttr);
-            assert.strictEqual(evalNameAttr.value.stringValue, 'test');
-        });
-        it('includes resource attributes', () => {
-            const result = evaluationsToConfidentTraces([baseEvaluation], baseConfig);
-            const resourceAttrs = result.resourceSpans[0].resource.attributes;
-            const serviceNameAttr = resourceAttrs.find(a => a.key === 'service.name');
-            assert.ok(serviceNameAttr);
-            assert.strictEqual(serviceNameAttr.value.stringValue, 'observability-toolkit');
-            const traceNameAttr = resourceAttrs.find(a => a.key === 'confident.trace.name');
-            assert.ok(traceNameAttr);
-            assert.strictEqual(traceNameAttr.value.stringValue, 'relevance');
-        });
-        it('handles empty evaluations array', () => {
-            const result = evaluationsToConfidentTraces([], baseConfig);
-            assert.strictEqual(result.resourceSpans[0].scopeSpans[0].spans.length, 0);
-        });
-        describe('extreme timestamp handling', () => {
-            it('accepts exactly year 2000 timestamp (minimum boundary)', () => {
-                const boundaryEval = {
-                    timestamp: '2000-01-01T00:00:00.000Z',
-                    evaluationName: 'test-boundary-min',
-                };
-                const result = evaluationsToConfidentTraces([boundaryEval], baseConfig);
-                const span = result.resourceSpans[0].scopeSpans[0].spans[0];
-                const startNano = BigInt(span.startTimeUnixNano);
-                const expectedMs = new Date('2000-01-01T00:00:00.000Z').getTime();
-                const expectedNs = BigInt(expectedMs) * BigInt(1_000_000);
-                assert.strictEqual(startNano, expectedNs);
-            });
-            it('accepts exactly year 3000 timestamp (maximum boundary)', () => {
-                const extremeEval = {
-                    timestamp: '3000-01-01T00:00:00Z',
-                    evaluationName: 'test-boundary-max',
-                };
-                const result = evaluationsToConfidentTraces([extremeEval], baseConfig);
-                const span = result.resourceSpans[0].scopeSpans[0].spans[0];
-                const startNano = BigInt(span.startTimeUnixNano);
-                const expectedMs = new Date('3000-01-01T00:00:00Z').getTime();
-                const expectedNs = BigInt(expectedMs) * BigInt(1_000_000);
-                assert.strictEqual(startNano, expectedNs);
-            });
-            it('uses fallback for year 9999 timestamps', () => {
-                const maxEval = {
-                    timestamp: '9999-12-31T23:59:59Z',
-                    evaluationName: 'test-max-date',
-                };
-                const result = evaluationsToConfidentTraces([maxEval], baseConfig);
-                const span = result.resourceSpans[0].scopeSpans[0].spans[0];
-                const startNano = BigInt(span.startTimeUnixNano);
-                const year9999Ms = new Date('9999-12-31T23:59:59Z').getTime();
-                const year9999Ns = BigInt(year9999Ms) * BigInt(1_000_000);
-                assert.ok(startNano < year9999Ns, 'Should use fallback time, not year 9999 timestamp');
-            });
-            it('uses fallback for invalid date strings', () => {
-                const invalidEval = {
-                    timestamp: 'not-a-valid-date',
-                    evaluationName: 'test-invalid',
-                };
-                const result = evaluationsToConfidentTraces([invalidEval], baseConfig);
-                const span = result.resourceSpans[0].scopeSpans[0].spans[0];
-                const event = span.events?.[0];
-                assert.ok(span.startTimeUnixNano);
-                assert.ok(event?.timeUnixNano);
-            });
-            it('uses fallback for timestamps before year 2000', () => {
-                const oldEval = {
-                    timestamp: '1999-12-31T23:59:59Z',
-                    evaluationName: 'test-old-date',
-                };
-                const result = evaluationsToConfidentTraces([oldEval], baseConfig);
-                const span = result.resourceSpans[0].scopeSpans[0].spans[0];
-                const startNano = BigInt(span.startTimeUnixNano);
-                const year1999Ms = new Date('1999-12-31T23:59:59Z').getTime();
-                const year1999Ns = BigInt(year1999Ms) * BigInt(1_000_000);
-                assert.ok(startNano > year1999Ns, 'Should use fallback time, not year 1999 timestamp');
-            });
-        });
-        describe('BigInt timestamp handling', () => {
-            it('handles timestamps near MAX_SAFE_INTEGER without precision loss', () => {
-                const farFutureEval = {
-                    timestamp: '2100-01-01T00:00:00Z',
-                    evaluationName: 'test-future',
-                };
-                const result = evaluationsToConfidentTraces([farFutureEval], baseConfig);
-                const span = result.resourceSpans[0].scopeSpans[0].spans[0];
-                const event = span.events?.[0];
-                assert.ok(span.startTimeUnixNano);
-                assert.ok(span.endTimeUnixNano);
-                assert.ok(event?.timeUnixNano);
-                const startNano = BigInt(span.startTimeUnixNano);
-                assert.ok(startNano > BigInt(Number.MAX_SAFE_INTEGER));
-                const expectedNs = BigInt(new Date('2100-01-01T00:00:00Z').getTime()) * BigInt(1_000_000);
-                assert.strictEqual(startNano, expectedNs);
-            });
-        });
-    });
-    describe('exportToConfident', () => {
-        const mockConfig = {
-            endpoint: 'https://otel.confident-ai.com',
-            apiKey: 'confident_us1234567890abcdefghij',
-            batchSize: 2,
-            timeoutMs: 5000,
-            environment: 'development',
-        };
-        const testEvaluations = [
-            { timestamp: '2024-01-15T10:00:00Z', evaluationName: 'eval1', scoreValue: 0.8 },
-            { timestamp: '2024-01-15T10:00:01Z', evaluationName: 'eval2', scoreValue: 0.9 },
-            { timestamp: '2024-01-15T10:00:02Z', evaluationName: 'eval3', scoreValue: 0.7 },
-        ];
-        it('batches evaluations correctly', async () => {
-            const fetchCalls = [];
-            const originalFetch = globalThis.fetch;
-            globalThis.fetch = mock.fn(async (url, opts) => {
-                fetchCalls.push({ url: url.toString(), body: opts?.body });
-                return new Response('{}', { status: HttpStatus.OK });
-            });
-            try {
-                const result = await exportToConfident(testEvaluations, mockConfig);
-                assert.strictEqual(result.success, true);
-                assert.strictEqual(result.evaluationsExported, 3);
-                assert.strictEqual(result.batches, 2);
-                assert.strictEqual(result.failed, 0);
-                assert.ok(result.durationMs >= 0);
-                assert.strictEqual(fetchCalls.length, 2);
-                assert.ok(fetchCalls[0].url.includes('/v1/traces'));
-            }
-            finally {
-                globalThis.fetch = originalFetch;
-            }
-        });
-        it('handles HTTP errors', async () => {
-            const originalFetch = globalThis.fetch;
-            globalThis.fetch = mock.fn(async () => {
-                return new Response('Unauthorized', { status: HttpStatus.UNAUTHORIZED });
-            });
-            try {
-                const result = await exportToConfident([testEvaluations[0]], mockConfig);
-                assert.strictEqual(result.success, false);
-                assert.strictEqual(result.evaluationsExported, 0);
-                assert.strictEqual(result.failed, 1);
-                assert.ok(result.errors);
-                assert.ok(result.errors[0].includes('HTTP 401'));
-            }
-            finally {
-                globalThis.fetch = originalFetch;
-            }
-        });
-        it('handles network errors', async () => {
-            const originalFetch = globalThis.fetch;
-            globalThis.fetch = mock.fn(async () => {
-                throw new Error('Network error');
-            });
-            try {
-                const result = await exportToConfident([testEvaluations[0]], mockConfig);
-                assert.strictEqual(result.success, false);
-                assert.strictEqual(result.failed, 1);
-                assert.ok(result.errors);
-                assert.ok(result.errors[0].includes('Network error'));
-            }
-            finally {
-                globalThis.fetch = originalFetch;
-            }
-        });
-        it('handles empty evaluations array', async () => {
-            const result = await exportToConfident([], mockConfig);
-            assert.strictEqual(result.success, true);
-            assert.strictEqual(result.evaluationsExported, 0);
-            assert.strictEqual(result.batches, 0);
-            assert.strictEqual(result.failed, 0);
-        });
-        it('includes correct x-confident-api-key header', async () => {
-            let capturedHeaders = {};
-            const originalFetch = globalThis.fetch;
-            globalThis.fetch = mock.fn(async (_url, opts) => {
-                capturedHeaders = Object.fromEntries(Object.entries(opts?.headers || {}));
-                return new Response('{}', { status: HttpStatus.OK });
-            });
-            try {
-                await exportToConfident([testEvaluations[0]], mockConfig);
-                assert.ok(capturedHeaders['x-confident-api-key']);
-                assert.strictEqual(capturedHeaders['x-confident-api-key'], 'confident_us1234567890abcdefghij');
-                assert.strictEqual(capturedHeaders['Content-Type'], 'application/json');
-            }
-            finally {
-                globalThis.fetch = originalFetch;
-            }
-        });
-        it('handles partial batch failures', async () => {
-            let callCount = 0;
-            const originalFetch = globalThis.fetch;
-            globalThis.fetch = mock.fn(async () => {
-                callCount++;
-                if (callCount === 1) {
-                    return new Response('{}', { status: HttpStatus.OK });
-                }
-                return new Response('Server Error', { status: HttpStatus.INTERNAL_SERVER_ERROR });
-            });
-            try {
-                const result = await exportToConfident(testEvaluations, {
-                    ...mockConfig,
-                    batchSize: 2,
-                });
-                assert.strictEqual(result.success, false);
-                assert.strictEqual(result.evaluationsExported, 2);
-                assert.strictEqual(result.failed, 1);
-                assert.strictEqual(result.batches, 2);
-            }
-            finally {
-                globalThis.fetch = originalFetch;
-            }
-        });
-        describe('credential sanitization in error responses', () => {
-            it('sanitizes Confident AI API key patterns in error text', async () => {
-                const originalFetch = globalThis.fetch;
-                const originalConsoleError = console.error;
-                let loggedMessage = '';
-                console.error = (msg) => { loggedMessage = msg; };
-                globalThis.fetch = mock.fn(async () => {
-                    return new Response('Invalid key: confident_us1234567890abcdefghij', { status: HttpStatus.UNAUTHORIZED });
-                });
-                try {
-                    await exportToConfident([testEvaluations[0]], mockConfig);
-                    assert.ok(!loggedMessage.includes('confident_us1234567890abcdefghij'), 'API key should be redacted');
-                    assert.ok(loggedMessage.includes('[REDACTED]'), 'Should contain [REDACTED]');
-                }
-                finally {
-                    globalThis.fetch = originalFetch;
-                    console.error = originalConsoleError;
-                }
-            });
-            it('sanitizes x-confident-api-key header patterns in error text', async () => {
-                const originalFetch = globalThis.fetch;
-                const originalConsoleError = console.error;
-                let loggedMessage = '';
-                console.error = (msg) => { loggedMessage = msg; };
-                globalThis.fetch = mock.fn(async () => {
-                    return new Response('Header x-confident-api-key: confident_us1234567890abcdefghij invalid', { status: HttpStatus.UNAUTHORIZED });
-                });
-                try {
-                    await exportToConfident([testEvaluations[0]], mockConfig);
-                    assert.ok(!loggedMessage.includes('confident_us1234567890abcdefghij'), 'API key should be redacted');
-                }
-                finally {
-                    globalThis.fetch = originalFetch;
-                    console.error = originalConsoleError;
-                }
-            });
-        });
-        describe('concurrent exports', () => {
-            it('handles multiple simultaneous exports without interference', async () => {
-                const fetchCalls = [];
-                let batchCounter = 0;
-                const originalFetch = globalThis.fetch;
-                globalThis.fetch = mock.fn(async () => {
-                    const batch = ++batchCounter;
-                    fetchCalls.push({ batch, timestamp: Date.now() });
-                    await new Promise(resolve => setTimeout(resolve, 10));
-                    return new Response('{}', { status: HttpStatus.OK });
-                });
-                try {
-                    const [result1, result2, result3] = await Promise.all([
-                        exportToConfident([testEvaluations[0]], { ...mockConfig, batchSize: 1 }),
-                        exportToConfident([testEvaluations[1]], { ...mockConfig, batchSize: 1 }),
-                        exportToConfident([testEvaluations[2]], { ...mockConfig, batchSize: 1 }),
-                    ]);
-                    assert.strictEqual(result1.success, true);
-                    assert.strictEqual(result2.success, true);
-                    assert.strictEqual(result3.success, true);
-                    assert.strictEqual(fetchCalls.length, 3);
-                    const totalExported = result1.evaluationsExported + result2.evaluationsExported + result3.evaluationsExported;
-                    assert.strictEqual(totalExported, 3);
-                }
-                finally {
-                    globalThis.fetch = originalFetch;
-                }
-            });
-        });
-        describe('memory protection', () => {
-            it('aborts export when memory exceeds threshold', async () => {
-                const originalMemoryUsage = process.memoryUsage;
-                let memoryCallCount = 0;
-                process.memoryUsage = (() => {
-                    memoryCallCount++;
-                    const heapUsed = memoryCallCount > 1 ? 700 * 1024 * 1024 : 100 * 1024 * 1024;
-                    return {
-                        heapUsed,
-                        heapTotal: 1024 * 1024 * 1024,
-                        external: 0,
-                        arrayBuffers: 0,
-                        rss: 0,
-                    };
-                });
-                const originalFetch = globalThis.fetch;
-                globalThis.fetch = mock.fn(async () => {
-                    return new Response('{}', { status: HttpStatus.OK });
-                });
-                try {
-                    const manyEvaluations = Array.from({ length: 100 }, (_, i) => ({
-                        timestamp: '2024-01-15T10:00:00Z',
-                        evaluationName: `eval-${i}`,
-                        scoreValue: 0.5,
-                    }));
-                    const result = await exportToConfident(manyEvaluations, {
-                        ...mockConfig,
-                        batchSize: 10,
-                    });
-                    assert.strictEqual(result.success, false);
-                    assert.ok(result.failed > 0);
-                    assert.ok(result.errors?.some(e => e.includes('Memory limit exceeded')));
-                    assert.ok(result.evaluationsExported < 100);
-                }
-                finally {
-                    process.memoryUsage = originalMemoryUsage;
-                    globalThis.fetch = originalFetch;
-                }
-            });
-        });
-        describe('DNS rebinding protection', () => {
-            it('re-validates endpoint before each batch', async () => {
-                let fetchCallCount = 0;
-                const originalFetch = globalThis.fetch;
-                globalThis.fetch = mock.fn(async () => {
-                    fetchCallCount++;
-                    return new Response('{}', { status: HttpStatus.OK });
-                });
-                try {
-                    const result = await exportToConfident(testEvaluations, {
-                        ...mockConfig,
-                        batchSize: 1,
-                    });
-                    assert.strictEqual(result.success, true);
-                    assert.strictEqual(result.batches, 3);
-                    assert.strictEqual(fetchCallCount, 3);
-                }
-                finally {
-                    globalThis.fetch = originalFetch;
-                }
-            });
-            it('fails batch if endpoint becomes invalid mid-export', async () => {
-                let fetchCallCount = 0;
-                const originalFetch = globalThis.fetch;
-                globalThis.fetch = mock.fn(async () => {
-                    fetchCallCount++;
-                    return new Response('{}', { status: HttpStatus.OK });
-                });
-                try {
-                    const result = await exportToConfident(testEvaluations, {
-                        ...mockConfig,
-                        endpoint: 'http://localhost',
-                        batchSize: 1,
-                    });
-                    assert.strictEqual(result.success, false);
-                    assert.strictEqual(result.failed, 3);
-                    assert.strictEqual(fetchCallCount, 0);
-                    assert.ok(result.errors?.some(e => e.includes('Endpoint validation failed')));
-                }
-                finally {
-                    globalThis.fetch = originalFetch;
-                }
-            });
-        });
-        describe('retry logic for transient failures', () => {
-            it('retries on 429 rate limit response', async () => {
-                let fetchCallCount = 0;
-                const originalFetch = globalThis.fetch;
-                globalThis.fetch = mock.fn(async () => {
-                    fetchCallCount++;
-                    if (fetchCallCount <= 2) {
-                        return new Response('Rate limited', { status: HttpStatus.TOO_MANY_REQUESTS });
-                    }
-                    return new Response('{}', { status: HttpStatus.OK });
-                });
-                try {
-                    const result = await exportToConfident([testEvaluations[0]], {
-                        ...mockConfig,
-                        timeoutMs: 100,
-                    });
-                    assert.strictEqual(result.success, true);
-                    assert.strictEqual(result.evaluationsExported, 1);
-                    assert.strictEqual(fetchCallCount, 3);
-                }
-                finally {
-                    globalThis.fetch = originalFetch;
-                }
-            });
-            it('retries on 500 server error', async () => {
-                let fetchCallCount = 0;
-                const originalFetch = globalThis.fetch;
-                globalThis.fetch = mock.fn(async () => {
-                    fetchCallCount++;
-                    if (fetchCallCount === 1) {
-                        return new Response('Internal Server Error', { status: HttpStatus.INTERNAL_SERVER_ERROR });
-                    }
-                    return new Response('{}', { status: HttpStatus.OK });
-                });
-                try {
-                    const result = await exportToConfident([testEvaluations[0]], {
-                        ...mockConfig,
-                        timeoutMs: 100,
-                    });
-                    assert.strictEqual(result.success, true);
-                    assert.strictEqual(result.evaluationsExported, 1);
-                    assert.strictEqual(fetchCallCount, 2);
-                }
-                finally {
-                    globalThis.fetch = originalFetch;
-                }
-            });
-            it('does not retry on 400 bad request', async () => {
-                let fetchCallCount = 0;
-                const originalFetch = globalThis.fetch;
-                globalThis.fetch = mock.fn(async () => {
-                    fetchCallCount++;
-                    return new Response('Bad Request', { status: HttpStatus.BAD_REQUEST });
-                });
-                try {
-                    const result = await exportToConfident([testEvaluations[0]], {
-                        ...mockConfig,
-                        timeoutMs: 100,
-                    });
-                    assert.strictEqual(result.success, false);
-                    assert.strictEqual(result.failed, 1);
-                    assert.strictEqual(fetchCallCount, 1);
-                }
-                finally {
-                    globalThis.fetch = originalFetch;
-                }
-            });
-            it('gives up after max retries on persistent 5xx', async () => {
-                let fetchCallCount = 0;
-                const originalFetch = globalThis.fetch;
-                globalThis.fetch = mock.fn(async () => {
-                    fetchCallCount++;
-                    return new Response('Server Error', { status: HttpStatus.INTERNAL_SERVER_ERROR });
-                });
-                try {
-                    const result = await exportToConfident([testEvaluations[0]], {
-                        ...mockConfig,
-                        timeoutMs: 100,
-                    });
-                    assert.strictEqual(result.success, false);
-                    assert.strictEqual(result.failed, 1);
-                    assert.strictEqual(fetchCallCount, 4);
-                    assert.ok(result.errors?.[0].includes('HTTP 500'));
-                }
-                finally {
-                    globalThis.fetch = originalFetch;
-                }
-            });
-            it('retries on network errors', async () => {
-                let fetchCallCount = 0;
-                const originalFetch = globalThis.fetch;
-                globalThis.fetch = mock.fn(async () => {
-                    fetchCallCount++;
-                    if (fetchCallCount <= 2) {
-                        const error = new TypeError('fetch failed');
-                        error.cause = new Error('ENOTFOUND');
-                        throw error;
-                    }
-                    return new Response('{}', { status: HttpStatus.OK });
-                });
-                try {
-                    const result = await exportToConfident([testEvaluations[0]], {
-                        ...mockConfig,
-                        timeoutMs: 100,
-                    });
-                    assert.strictEqual(result.success, true);
-                    assert.strictEqual(result.evaluationsExported, 1);
-                    assert.strictEqual(fetchCallCount, 3);
-                }
-                finally {
-                    globalThis.fetch = originalFetch;
-                }
-            });
-        });
-    });
-});
-//# sourceMappingURL=confident-export.test.js.map