@pauly4010/evalai-sdk 1.3.0

package/dist/export.d.ts

@@ -0,0 +1,195 @@
+/**
+ * Data Export/Import System
+ * Tier 4.18: Platform migration and backup utilities
+ *
+ * @example
+ * ```typescript
+ * import { exportData, importData } from '@ai-eval-platform/sdk';
+ *
+ * // Export all data
+ * const data = await exportData(client, {
+ *   format: 'json',
+ *   includeTraces: true,
+ *   includeEvaluations: true
+ * });
+ *
+ * // Save to file
+ * fs.writeFileSync('backup.json', JSON.stringify(data, null, 2));
+ *
+ * // Import from another platform
+ * await importFromLangSmith(client, langsmithData);
+ * ```
+ */
+import type { AIEvalClient } from './client';
+import type { Trace, Evaluation, TestCase, EvaluationRun } from './types';
+export type ExportFormat = 'json' | 'csv' | 'jsonl';
+export type { ExportFormat as ExportType };
+export interface ExportOptions {
+    /** Export format */
+    format: 'json' | 'csv' | 'jsonl';
+    /** Include traces */
+    includeTraces?: boolean;
+    /** Include evaluations */
+    includeEvaluations?: boolean;
+    /** Include test cases */
+    includeTestCases?: boolean;
+    /** Include evaluation runs */
+    includeRuns?: boolean;
+    /** Date range filter */
+    dateRange?: {
+        from: string;
+        to: string;
+    };
+    /** Organization ID filter */
+    organizationId?: number;
+    /** Maximum items to export (default: no limit) */
+    limit?: number;
+}
+export interface ExportData {
+    /** Export metadata */
+    metadata: {
+        exportedAt: string;
+        version: string;
+        format: string;
+        organizationId?: number;
+    };
+    /** Exported traces */
+    traces?: Trace[];
+    /** Exported evaluations */
+    evaluations?: Evaluation[];
+    /** Exported test cases */
+    testCases?: TestCase[];
+    /** Exported runs */
+    runs?: EvaluationRun[];
+}
+export interface ImportOptions {
+    /** Organization ID to import into */
+    organizationId?: number;
+    /** User ID for created resources */
+    createdBy?: number;
+    /** Skip duplicates (based on name) */
+    skipDuplicates?: boolean;
+    /** Dry run (don't actually import) */
+    dryRun?: boolean;
+}
+export interface ImportResult {
+    /** Import summary */
+    summary: {
+        total: number;
+        imported: number;
+        skipped: number;
+        failed: number;
+    };
+    /** Detailed results */
+    details: {
+        traces?: {
+            imported: number;
+            skipped: number;
+            failed: number;
+        };
+        evaluations?: {
+            imported: number;
+            skipped: number;
+            failed: number;
+        };
+        testCases?: {
+            imported: number;
+            skipped: number;
+            failed: number;
+        };
+        runs?: {
+            imported: number;
+            skipped: number;
+            failed: number;
+        };
+    };
+    /** Errors encountered */
+    errors?: Array<{
+        item: string;
+        error: string;
+    }>;
+}
+/**
+ * Export data from the platform
+ *
+ * @example
+ * ```typescript
+ * const data = await exportData(client, {
+ *   format: 'json',
+ *   includeTraces: true,
+ *   includeEvaluations: true,
+ *   dateRange: { from: '2024-01-01', to: '2024-12-31' }
+ * });
+ *
+ * // Save to file
+ * fs.writeFileSync('backup.json', JSON.stringify(data, null, 2));
+ * ```
+ */
+export declare function exportData(client: AIEvalClient, options: ExportOptions): Promise<ExportData>;
+/**
+ * Import data into the platform
+ *
+ * @example
+ * ```typescript
+ * const data = JSON.parse(fs.readFileSync('backup.json', 'utf-8'));
+ * const result = await importData(client, data, {
+ *   organizationId: 123,
+ *   skipDuplicates: true
+ * });
+ *
+ * console.log(`Imported ${result.summary.imported} items`);
+ * ```
+ */
+export declare function importData(client: AIEvalClient, data: ExportData, options: ImportOptions): Promise<ImportResult>;
+/**
+ * Export data to JSON file
+ *
+ * @example
+ * ```typescript
+ * await exportToFile(client, './backup.json', {
+ *   includeTraces: true,
+ *   includeEvaluations: true
+ * });
+ * ```
+ */
+export declare function exportToFile(client: AIEvalClient, filePath: string, options: Omit<ExportOptions, 'format'>): Promise<void>;
+/**
+ * Import data from JSON file
+ *
+ * @example
+ * ```typescript
+ * const result = await importFromFile(client, './backup.json', {
+ *   organizationId: 123,
+ *   createdBy: 1
+ * });
+ * ```
+ */
+export declare function importFromFile(client: AIEvalClient, filePath: string, options: ImportOptions): Promise<ImportResult>;
+/**
+ * Import from LangSmith format
+ *
+ * @example
+ * ```typescript
+ * const langsmithData = {
+ *   runs: [
+ *     { name: 'test-1', inputs: { ... }, outputs: { ... } }
+ *   ]
+ * };
+ *
+ * await importFromLangSmith(client, langsmithData, {
+ *   organizationId: 123
+ * });
+ * ```
+ */
+export declare function importFromLangSmith(client: AIEvalClient, langsmithData: any, options: ImportOptions): Promise<ImportResult>;
+/**
+ * Convert export data to CSV format
+ *
+ * @example
+ * ```typescript
+ * const data = await exportData(client, { format: 'json', includeTraces: true });
+ * const csv = convertToCSV(data, 'traces');
+ * fs.writeFileSync('traces.csv', csv);
+ * ```
+ */
+export declare function convertToCSV(data: ExportData, type: 'traces' | 'evaluations'): string;

package/dist/export.js

@@ -0,0 +1,334 @@
+"use strict";
+/**
+ * Data Export/Import System
+ * Tier 4.18: Platform migration and backup utilities
+ *
+ * @example
+ * ```typescript
+ * import { exportData, importData } from '@ai-eval-platform/sdk';
+ *
+ * // Export all data
+ * const data = await exportData(client, {
+ *   format: 'json',
+ *   includeTraces: true,
+ *   includeEvaluations: true
+ * });
+ *
+ * // Save to file
+ * fs.writeFileSync('backup.json', JSON.stringify(data, null, 2));
+ *
+ * // Import from another platform
+ * await importFromLangSmith(client, langsmithData);
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportData = exportData;
+exports.importData = importData;
+exports.exportToFile = exportToFile;
+exports.importFromFile = importFromFile;
+exports.importFromLangSmith = importFromLangSmith;
+exports.convertToCSV = convertToCSV;
+/**
+ * Export data from the platform
+ *
+ * @example
+ * ```typescript
+ * const data = await exportData(client, {
+ *   format: 'json',
+ *   includeTraces: true,
+ *   includeEvaluations: true,
+ *   dateRange: { from: '2024-01-01', to: '2024-12-31' }
+ * });
+ *
+ * // Save to file
+ * fs.writeFileSync('backup.json', JSON.stringify(data, null, 2));
+ * ```
+ */
+async function exportData(client, options) {
+    const exportData = {
+        metadata: {
+            exportedAt: new Date().toISOString(),
+            version: '1.0.0',
+            format: options.format,
+            organizationId: options.organizationId
+        }
+    };
+    // Export traces
+    if (options.includeTraces) {
+        const traces = await client.traces.list({
+            organizationId: options.organizationId,
+            limit: options.limit
+        });
+        exportData.traces = traces;
+    }
+    // Export evaluations
+    if (options.includeEvaluations) {
+        const evaluations = await client.evaluations.list({
+            organizationId: options.organizationId,
+            limit: options.limit
+        });
+        exportData.evaluations = evaluations;
+        // Export test cases for each evaluation
+        if (options.includeTestCases) {
+            const allTestCases = [];
+            for (const evaluation of evaluations) {
+                const testCases = await client.evaluations.listTestCases(evaluation.id);
+                allTestCases.push(...testCases);
+            }
+            exportData.testCases = allTestCases;
+        }
+        // Export runs for each evaluation
+        if (options.includeRuns) {
+            const allRuns = [];
+            for (const evaluation of evaluations) {
+                const runs = await client.evaluations.listRuns(evaluation.id);
+                allRuns.push(...runs);
+            }
+            exportData.runs = allRuns;
+        }
+    }
+    return exportData;
+}
+/**
+ * Import data into the platform
+ *
+ * @example
+ * ```typescript
+ * const data = JSON.parse(fs.readFileSync('backup.json', 'utf-8'));
+ * const result = await importData(client, data, {
+ *   organizationId: 123,
+ *   skipDuplicates: true
+ * });
+ *
+ * console.log(`Imported ${result.summary.imported} items`);
+ * ```
+ */
+async function importData(client, data, options) {
+    const result = {
+        summary: { total: 0, imported: 0, skipped: 0, failed: 0 },
+        details: {},
+        errors: []
+    };
+    if (options.dryRun) {
+        // Count what would be imported
+        if (data.traces)
+            result.summary.total += data.traces.length;
+        if (data.evaluations)
+            result.summary.total += data.evaluations.length;
+        if (data.testCases)
+            result.summary.total += data.testCases.length;
+        if (data.runs)
+            result.summary.total += data.runs.length;
+        return result;
+    }
+    // Import traces
+    if (data.traces) {
+        const traceResults = { imported: 0, skipped: 0, failed: 0 };
+        for (const trace of data.traces) {
+            try {
+                await client.traces.create({
+                    name: trace.name,
+                    traceId: trace.traceId,
+                    organizationId: options.organizationId || trace.organizationId,
+                    status: trace.status,
+                    durationMs: trace.durationMs || undefined,
+                    metadata: trace.metadata || undefined
+                });
+                traceResults.imported++;
+                result.summary.imported++;
+            }
+            catch (error) {
+                if (options.skipDuplicates && error instanceof Error && error.message.includes('already exists')) {
+                    traceResults.skipped++;
+                    result.summary.skipped++;
+                }
+                else {
+                    traceResults.failed++;
+                    result.summary.failed++;
+                    result.errors?.push({
+                        item: `trace:${trace.traceId}`,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+        }
+        result.details.traces = traceResults;
+        result.summary.total += data.traces.length;
+    }
+    // Import evaluations
+    if (data.evaluations) {
+        const evalResults = { imported: 0, skipped: 0, failed: 0 };
+        for (const evaluation of data.evaluations) {
+            try {
+                if (!options.createdBy) {
+                    throw new Error('createdBy is required for importing evaluations');
+                }
+                await client.evaluations.create({
+                    name: evaluation.name,
+                    description: evaluation.description || undefined,
+                    type: evaluation.type,
+                    organizationId: options.organizationId || evaluation.organizationId,
+                    createdBy: options.createdBy,
+                    status: evaluation.status
+                });
+                evalResults.imported++;
+                result.summary.imported++;
+            }
+            catch (error) {
+                if (options.skipDuplicates && error instanceof Error && error.message.includes('already exists')) {
+                    evalResults.skipped++;
+                    result.summary.skipped++;
+                }
+                else {
+                    evalResults.failed++;
+                    result.summary.failed++;
+                    result.errors?.push({
+                        item: `evaluation:${evaluation.name}`,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+        }
+        result.details.evaluations = evalResults;
+        result.summary.total += data.evaluations.length;
+    }
+    return result;
+}
+/**
+ * Export data to JSON file
+ *
+ * @example
+ * ```typescript
+ * await exportToFile(client, './backup.json', {
+ *   includeTraces: true,
+ *   includeEvaluations: true
+ * });
+ * ```
+ */
+async function exportToFile(client, filePath, options) {
+    const data = await exportData(client, { ...options, format: 'json' });
+    const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+}
+/**
+ * Import data from JSON file
+ *
+ * @example
+ * ```typescript
+ * const result = await importFromFile(client, './backup.json', {
+ *   organizationId: 123,
+ *   createdBy: 1
+ * });
+ * ```
+ */
+async function importFromFile(client, filePath, options) {
+    const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const data = JSON.parse(content);
+    return importData(client, data, options);
+}
+/**
+ * Import from LangSmith format
+ *
+ * @example
+ * ```typescript
+ * const langsmithData = {
+ *   runs: [
+ *     { name: 'test-1', inputs: { ... }, outputs: { ... } }
+ *   ]
+ * };
+ *
+ * await importFromLangSmith(client, langsmithData, {
+ *   organizationId: 123
+ * });
+ * ```
+ */
+async function importFromLangSmith(client, langsmithData, options) {
+    // Transform LangSmith format to our format
+    const transformedData = {
+        metadata: {
+            exportedAt: new Date().toISOString(),
+            version: '1.0.0',
+            format: 'json',
+            organizationId: options.organizationId
+        },
+        traces: []
+    };
+    // Transform runs to traces
+    if (langsmithData.runs && Array.isArray(langsmithData.runs)) {
+        transformedData.traces = langsmithData.runs.map((run) => ({
+            name: run.name || 'Imported Trace',
+            traceId: run.id || `langsmith-${Date.now()}-${Math.random()}`,
+            organizationId: options.organizationId,
+            status: run.error ? 'error' : 'success',
+            durationMs: run.execution_time ? Math.round(run.execution_time * 1000) : null,
+            metadata: {
+                source: 'langsmith',
+                original_id: run.id,
+                inputs: run.inputs,
+                outputs: run.outputs
+            },
+            createdAt: run.start_time || new Date().toISOString()
+        }));
+    }
+    return importData(client, transformedData, options);
+}
+/**
+ * Convert export data to CSV format
+ *
+ * @example
+ * ```typescript
+ * const data = await exportData(client, { format: 'json', includeTraces: true });
+ * const csv = convertToCSV(data, 'traces');
+ * fs.writeFileSync('traces.csv', csv);
+ * ```
+ */
+function convertToCSV(data, type) {
+    const items = type === 'traces' ? data.traces : data.evaluations;
+    if (!items || items.length === 0)
+        return '';
+    // Get headers from first item
+    const headers = Object.keys(items[0]);
+    const rows = items.map(item => headers.map(h => {
+        const value = item[h];
+        if (value === null || value === undefined)
+            return '';
+        if (typeof value === 'object')
+            return JSON.stringify(value);
+        return String(value);
+    }).join(','));
+    return [headers.join(','), ...rows].join('\n');
+}

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * AI Evaluation Platform SDK
+ *
+ * Official TypeScript/JavaScript SDK for the AI Evaluation Platform.
+ * Build confidence in your AI systems with comprehensive evaluation tools.
+ *
+ * @packageDocumentation
+ */
+export { AIEvalClient } from './client';
+import { EvalAIError, RateLimitError, AuthenticationError, NetworkError, SDKError } from './errors';
+export { EvalAIError, RateLimitError, AuthenticationError, SDKError as ValidationError, // Using SDKError as ValidationError for backward compatibility
+NetworkError };
+export { expect, containsKeywords, matchesPattern, hasLength, containsJSON, notContainsPII, hasSentiment, similarTo, withinRange, isValidEmail, isValidURL, hasNoHallucinations, matchesSchema, hasReadabilityScore, containsLanguage, hasFactualAccuracy, respondedWithinTime, hasNoToxicity, followsInstructions, containsAllRequiredFields, hasValidCodeSyntax } from './assertions';
+import { createContext, getCurrentContext, withContext, EvalContext } from './context';
+export { createContext, getCurrentContext as getContext, withContext, EvalContext as ContextManager };
+export { createTestSuite, TestSuite, TestSuiteCase, TestSuiteCaseResult, TestSuiteResult, TestSuiteConfig, type TestCaseResult } from './testing';
+import { snapshot, compareWithSnapshot } from './snapshot';
+export { snapshot, compareWithSnapshot, snapshot as saveSnapshot, compareWithSnapshot as compareSnapshots };
+import { exportData, importData } from './export';
+import type { ExportFormat } from './export';
+export { exportData, importData };
+export type { ExportFormat, ExportFormat as ExportType };
+export { batchProcess, streamEvaluation, batchRead, RateLimiter } from './streaming';
+export { RequestCache, CacheTTL } from './cache';
+export { PaginatedIterator, createPaginatedIterator, autoPaginate, encodeCursor, decodeCursor, type PaginatedResponse, type PaginationParams } from './pagination';
+export { RequestBatcher } from './batch';
+export { Logger } from './logger';
+export { traceOpenAI } from './integrations/openai';
+export { traceAnthropic } from './integrations/anthropic';
+export { WorkflowTracer, createWorkflowTracer, traceWorkflowStep, traceLangChainAgent, traceCrewAI, traceAutoGen, type WorkflowNode, type WorkflowEdge, type WorkflowDefinition, type WorkflowContext, type WorkflowStatus, type HandoffType, type AgentHandoff, type DecisionAlternative, type DecisionType, type RecordDecisionParams, type LLMProvider, type CostCategory, type RecordCostParams, type CostRecord, type WorkflowTracerOptions, type AgentSpanContext, } from './workflows';
+export type { ClientConfig as AIEvalConfig, Trace as TraceData, Span as SpanData, Evaluation as EvaluationData, LLMJudgeResult as LLMJudgeData, RetryConfig, GenericMetadata as AnnotationData, TracedResponse, TestCase, TestResult, SnapshotData, ExportOptions, ImportOptions, StreamOptions, BatchOptions } from './types';
+export { EvaluationTemplates, type EvaluationTemplateType, type FeatureUsage, type OrganizationLimits } from './types';
+export type { Annotation, CreateAnnotationParams, ListAnnotationsParams, AnnotationTask, CreateAnnotationTaskParams, ListAnnotationTasksParams, AnnotationItem, CreateAnnotationItemParams, ListAnnotationItemsParams, APIKey, APIKeyWithSecret, CreateAPIKeyParams, UpdateAPIKeyParams, ListAPIKeysParams, APIKeyUsage, Webhook, CreateWebhookParams, UpdateWebhookParams, ListWebhooksParams, WebhookDelivery, ListWebhookDeliveriesParams, UsageStats, GetUsageParams, UsageSummary, LLMJudgeConfig, CreateLLMJudgeConfigParams, ListLLMJudgeConfigsParams, ListLLMJudgeResultsParams, LLMJudgeAlignment, GetLLMJudgeAlignmentParams, Organization, } from './types';
+import { AIEvalClient } from './client';
+export default AIEvalClient;

package/dist/index.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * AI Evaluation Platform SDK
+ *
+ * Official TypeScript/JavaScript SDK for the AI Evaluation Platform.
+ * Build confidence in your AI systems with comprehensive evaluation tools.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeCursor = exports.encodeCursor = exports.autoPaginate = exports.createPaginatedIterator = exports.PaginatedIterator = exports.CacheTTL = exports.RequestCache = exports.RateLimiter = exports.batchRead = exports.streamEvaluation = exports.batchProcess = exports.importData = exports.exportData = exports.compareSnapshots = exports.saveSnapshot = exports.compareWithSnapshot = exports.snapshot = exports.TestSuite = exports.createTestSuite = exports.ContextManager = exports.withContext = exports.getContext = exports.createContext = exports.hasValidCodeSyntax = exports.containsAllRequiredFields = exports.followsInstructions = exports.hasNoToxicity = exports.respondedWithinTime = exports.hasFactualAccuracy = exports.containsLanguage = exports.hasReadabilityScore = exports.matchesSchema = exports.hasNoHallucinations = exports.isValidURL = exports.isValidEmail = exports.withinRange = exports.similarTo = exports.hasSentiment = exports.notContainsPII = exports.containsJSON = exports.hasLength = exports.matchesPattern = exports.containsKeywords = exports.expect = exports.NetworkError = exports.ValidationError = exports.AuthenticationError = exports.RateLimitError = exports.EvalAIError = exports.AIEvalClient = void 0;
+exports.EvaluationTemplates = exports.traceAutoGen = exports.traceCrewAI = exports.traceLangChainAgent = exports.traceWorkflowStep = exports.createWorkflowTracer = exports.WorkflowTracer = exports.traceAnthropic = exports.traceOpenAI = exports.Logger = exports.RequestBatcher = void 0;
+// Main SDK exports
+var client_1 = require("./client");
+Object.defineProperty(exports, "AIEvalClient", { enumerable: true, get: function () { return client_1.AIEvalClient; } });
+// Enhanced error handling (Tier 1.5)
+const errors_1 = require("./errors");
+Object.defineProperty(exports, "EvalAIError", { enumerable: true, get: function () { return errors_1.EvalAIError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return errors_1.RateLimitError; } });
+Object.defineProperty(exports, "AuthenticationError", { enumerable: true, get: function () { return errors_1.AuthenticationError; } });
+Object.defineProperty(exports, "NetworkError", { enumerable: true, get: function () { return errors_1.NetworkError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return errors_1.SDKError; } });
+// Enhanced assertions (Tier 1.3)
+var assertions_1 = require("./assertions");
+Object.defineProperty(exports, "expect", { enumerable: true, get: function () { return assertions_1.expect; } });
+Object.defineProperty(exports, "containsKeywords", { enumerable: true, get: function () { return assertions_1.containsKeywords; } });
+Object.defineProperty(exports, "matchesPattern", { enumerable: true, get: function () { return assertions_1.matchesPattern; } });
+Object.defineProperty(exports, "hasLength", { enumerable: true, get: function () { return assertions_1.hasLength; } });
+Object.defineProperty(exports, "containsJSON", { enumerable: true, get: function () { return assertions_1.containsJSON; } });
+Object.defineProperty(exports, "notContainsPII", { enumerable: true, get: function () { return assertions_1.notContainsPII; } });
+Object.defineProperty(exports, "hasSentiment", { enumerable: true, get: function () { return assertions_1.hasSentiment; } });
+Object.defineProperty(exports, "similarTo", { enumerable: true, get: function () { return assertions_1.similarTo; } });
+Object.defineProperty(exports, "withinRange", { enumerable: true, get: function () { return assertions_1.withinRange; } });
+Object.defineProperty(exports, "isValidEmail", { enumerable: true, get: function () { return assertions_1.isValidEmail; } });
+Object.defineProperty(exports, "isValidURL", { enumerable: true, get: function () { return assertions_1.isValidURL; } });
+Object.defineProperty(exports, "hasNoHallucinations", { enumerable: true, get: function () { return assertions_1.hasNoHallucinations; } });
+Object.defineProperty(exports, "matchesSchema", { enumerable: true, get: function () { return assertions_1.matchesSchema; } });
+Object.defineProperty(exports, "hasReadabilityScore", { enumerable: true, get: function () { return assertions_1.hasReadabilityScore; } });
+Object.defineProperty(exports, "containsLanguage", { enumerable: true, get: function () { return assertions_1.containsLanguage; } });
+Object.defineProperty(exports, "hasFactualAccuracy", { enumerable: true, get: function () { return assertions_1.hasFactualAccuracy; } });
+Object.defineProperty(exports, "respondedWithinTime", { enumerable: true, get: function () { return assertions_1.respondedWithinTime; } });
+Object.defineProperty(exports, "hasNoToxicity", { enumerable: true, get: function () { return assertions_1.hasNoToxicity; } });
+Object.defineProperty(exports, "followsInstructions", { enumerable: true, get: function () { return assertions_1.followsInstructions; } });
+Object.defineProperty(exports, "containsAllRequiredFields", { enumerable: true, get: function () { return assertions_1.containsAllRequiredFields; } });
+Object.defineProperty(exports, "hasValidCodeSyntax", { enumerable: true, get: function () { return assertions_1.hasValidCodeSyntax; } });
+// Context propagation (Tier 2.9)
+const context_1 = require("./context");
+Object.defineProperty(exports, "createContext", { enumerable: true, get: function () { return context_1.createContext; } });
+Object.defineProperty(exports, "getContext", { enumerable: true, get: function () { return context_1.getCurrentContext; } });
+Object.defineProperty(exports, "withContext", { enumerable: true, get: function () { return context_1.withContext; } });
+Object.defineProperty(exports, "ContextManager", { enumerable: true, get: function () { return context_1.EvalContext; } });
+// Test suite builder (Tier 2.7)
+var testing_1 = require("./testing");
+Object.defineProperty(exports, "createTestSuite", { enumerable: true, get: function () { return testing_1.createTestSuite; } });
+Object.defineProperty(exports, "TestSuite", { enumerable: true, get: function () { return testing_1.TestSuite; } });
+// Snapshot testing (Tier 2.8)
+const snapshot_1 = require("./snapshot");
+Object.defineProperty(exports, "snapshot", { enumerable: true, get: function () { return snapshot_1.snapshot; } });
+Object.defineProperty(exports, "saveSnapshot", { enumerable: true, get: function () { return snapshot_1.snapshot; } });
+Object.defineProperty(exports, "compareWithSnapshot", { enumerable: true, get: function () { return snapshot_1.compareWithSnapshot; } });
+Object.defineProperty(exports, "compareSnapshots", { enumerable: true, get: function () { return snapshot_1.compareWithSnapshot; } });
+// Export/Import utilities (Tier 4.18)
+const export_1 = require("./export");
+Object.defineProperty(exports, "exportData", { enumerable: true, get: function () { return export_1.exportData; } });
+Object.defineProperty(exports, "importData", { enumerable: true, get: function () { return export_1.importData; } });
+// Streaming and batch processing (Tier 3.3)
+// Use functions from ./streaming module instead of these deprecated exports
+var streaming_1 = require("./streaming");
+Object.defineProperty(exports, "batchProcess", { enumerable: true, get: function () { return streaming_1.batchProcess; } });
+Object.defineProperty(exports, "streamEvaluation", { enumerable: true, get: function () { return streaming_1.streamEvaluation; } });
+Object.defineProperty(exports, "batchRead", { enumerable: true, get: function () { return streaming_1.batchRead; } });
+Object.defineProperty(exports, "RateLimiter", { enumerable: true, get: function () { return streaming_1.RateLimiter; } });
+// Performance optimization utilities (v1.3.0)
+// Note: RequestCache and CacheTTL are for advanced users only
+// Most users don't need these - caching is automatic
+var cache_1 = require("./cache");
+Object.defineProperty(exports, "RequestCache", { enumerable: true, get: function () { return cache_1.RequestCache; } });
+Object.defineProperty(exports, "CacheTTL", { enumerable: true, get: function () { return cache_1.CacheTTL; } });
+var pagination_1 = require("./pagination");
+Object.defineProperty(exports, "PaginatedIterator", { enumerable: true, get: function () { return pagination_1.PaginatedIterator; } });
+Object.defineProperty(exports, "createPaginatedIterator", { enumerable: true, get: function () { return pagination_1.createPaginatedIterator; } });
+Object.defineProperty(exports, "autoPaginate", { enumerable: true, get: function () { return pagination_1.autoPaginate; } });
+Object.defineProperty(exports, "encodeCursor", { enumerable: true, get: function () { return pagination_1.encodeCursor; } });
+Object.defineProperty(exports, "decodeCursor", { enumerable: true, get: function () { return pagination_1.decodeCursor; } });
+// Note: RequestBatcher is for advanced users only
+// Most users don't need this - batching is automatic
+var batch_1 = require("./batch");
+Object.defineProperty(exports, "RequestBatcher", { enumerable: true, get: function () { return batch_1.RequestBatcher; } });
+// Debug logger (Tier 4.17)
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
+// Framework integrations (Tier 1.2)
+var openai_1 = require("./integrations/openai");
+Object.defineProperty(exports, "traceOpenAI", { enumerable: true, get: function () { return openai_1.traceOpenAI; } });
+var anthropic_1 = require("./integrations/anthropic");
+Object.defineProperty(exports, "traceAnthropic", { enumerable: true, get: function () { return anthropic_1.traceAnthropic; } });
+// Workflow tracing (Orchestration Layer)
+var workflows_1 = require("./workflows");
+Object.defineProperty(exports, "WorkflowTracer", { enumerable: true, get: function () { return workflows_1.WorkflowTracer; } });
+Object.defineProperty(exports, "createWorkflowTracer", { enumerable: true, get: function () { return workflows_1.createWorkflowTracer; } });
+Object.defineProperty(exports, "traceWorkflowStep", { enumerable: true, get: function () { return workflows_1.traceWorkflowStep; } });
+// Framework integrations
+Object.defineProperty(exports, "traceLangChainAgent", { enumerable: true, get: function () { return workflows_1.traceLangChainAgent; } });
+Object.defineProperty(exports, "traceCrewAI", { enumerable: true, get: function () { return workflows_1.traceCrewAI; } });
+Object.defineProperty(exports, "traceAutoGen", { enumerable: true, get: function () { return workflows_1.traceAutoGen; } });
+// New exports for v1.1.0
+var types_1 = require("./types");
+Object.defineProperty(exports, "EvaluationTemplates", { enumerable: true, get: function () { return types_1.EvaluationTemplates; } });
+// Default export for convenience
+const client_2 = require("./client");
+exports.default = client_2.AIEvalClient;