@evalgate/sdk 2.0.0

package/dist/export.js

@@ -0,0 +1,344 @@
+"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("node: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("node: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
+    const lsData = langsmithData;
+    if (lsData.runs && Array.isArray(lsData.runs)) {
+        transformedData.traces = lsData.runs.map((run) => ({
+            id: run.id || 0,
+            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,44 @@
+/**
+ * EvalGate SDK
+ *
+ * Official TypeScript/JavaScript SDK for EvalGate.
+ * Build confidence in your AI systems with comprehensive evaluation tools.
+ *
+ * @packageDocumentation
+ */
+export { AIEvalClient } from "./client";
+import { AuthenticationError, EvalGateError, NetworkError, RateLimitError, SDKError } from "./errors";
+export { EvalGateError, RateLimitError, AuthenticationError, SDKError as ValidationError, // Using SDKError as ValidationError for backward compatibility
+NetworkError, };
+export { containsAllRequiredFields, containsJSON, containsKeywords, containsLanguage, expect, followsInstructions, hasFactualAccuracy, hasLength, hasNoHallucinations, hasNoToxicity, hasReadabilityScore, hasSentiment, hasValidCodeSyntax, isValidEmail, isValidURL, matchesPattern, matchesSchema, notContainsPII, respondedWithinTime, similarTo, withinRange, } from "./assertions";
+import { createContext, EvalContext, getCurrentContext, withContext } from "./context";
+export { createContext, getCurrentContext as getContext, withContext, EvalContext as ContextManager, };
+export { cloneContext, mergeContexts, validateContext, } from "./runtime/context";
+export { createContext as createEvalContext, createResult, defineEval, defineSuite, evalai, } from "./runtime/eval";
+export { createLocalExecutor, defaultLocalExecutor, } from "./runtime/executor";
+export { createEvalRuntime, disposeActiveRuntime, getActiveRuntime, setActiveRuntime, } from "./runtime/registry";
+export type { CloudExecutor, DefineEvalFunction, EvalContext, EvalExecutor, EvalExecutorInterface, EvalOptions, EvalResult, EvalRuntime, EvalSpec, ExecutorCapabilities, LocalExecutor, SpecConfig, SpecOptions, WorkerExecutor, } from "./runtime/types";
+export { EvalRuntimeError, RuntimeError, SpecExecutionError, SpecRegistrationError, } from "./runtime/types";
+export { createTestSuite, type TestCaseResult, TestSuite, TestSuiteCase, TestSuiteCaseResult, TestSuiteConfig, TestSuiteResult, } from "./testing";
+import { compareWithSnapshot, snapshot } from "./snapshot";
+export { snapshot, compareWithSnapshot, snapshot as saveSnapshot, compareWithSnapshot as compareSnapshots, };
+import type { ExportFormat } from "./export";
+import { exportData, importData } from "./export";
+export { exportData, importData };
+export type { ExportFormat, ExportFormat as ExportType };
+export { RequestBatcher } from "./batch";
+export { CacheTTL, RequestCache } from "./cache";
+export { type CheckArgs, EXIT, parseArgs, runCheck } from "./cli/check";
+export { traceAnthropic } from "./integrations/anthropic";
+export { traceOpenAI } from "./integrations/openai";
+export { type OpenAIChatEvalCase, type OpenAIChatEvalOptions, type OpenAIChatEvalResult, openAIChatEval, } from "./integrations/openai-eval";
+export { Logger } from "./logger";
+export { extendExpectWithToPassGate } from "./matchers";
+export { autoPaginate, createPaginatedIterator, decodeCursor, encodeCursor, PaginatedIterator, type PaginatedResponse, type PaginationParams, } from "./pagination";
+export { ARTIFACTS, type Baseline, type BaselineTolerance, GATE_CATEGORY, GATE_EXIT, type GateCategory, type GateExitCode, REPORT_SCHEMA_VERSION, type RegressionDelta, type RegressionReport, } from "./regression";
+export { batchProcess, batchRead, RateLimiter, streamEvaluation, } from "./streaming";
+export type { Annotation, AnnotationItem, AnnotationTask, APIKey, APIKeyUsage, APIKeyWithSecret, BatchOptions, ClientConfig as AIEvalConfig, CreateAnnotationItemParams, CreateAnnotationParams, CreateAnnotationTaskParams, CreateAPIKeyParams, CreateLLMJudgeConfigParams, CreateWebhookParams, Evaluation as EvaluationData, EvaluationRun, EvaluationRunDetail, ExportOptions, GenericMetadata as AnnotationData, GetLLMJudgeAlignmentParams, GetUsageParams, ImportOptions, ListAnnotationItemsParams, ListAnnotationsParams, ListAnnotationTasksParams, ListAPIKeysParams, ListLLMJudgeConfigsParams, ListLLMJudgeResultsParams, ListWebhookDeliveriesParams, ListWebhooksParams, LLMJudgeAlignment, LLMJudgeConfig, LLMJudgeEvaluateResult, LLMJudgeResult as LLMJudgeData, Organization, RetryConfig, SnapshotData, Span as SpanData, StreamOptions, TestCase, TestResult, Trace as TraceData, TraceDetail, TracedResponse, UpdateAPIKeyParams, UpdateWebhookParams, UsageStats, UsageSummary, Webhook, WebhookDelivery, } from "./types";
+export { EvaluationTemplates, type EvaluationTemplateType, type FeatureUsage, type OrganizationLimits, } from "./types";
+export { type AgentHandoff, type AgentSpanContext, type CostCategory, type CostRecord, createWorkflowTracer, type DecisionAlternative, type DecisionType, type HandoffType, type LLMProvider, type RecordCostParams, type RecordDecisionParams, traceAutoGen, traceCrewAI, traceLangChainAgent, traceWorkflowStep, type WorkflowContext, type WorkflowDefinition, type WorkflowEdge, type WorkflowNode, type WorkflowStatus, WorkflowTracer, type WorkflowTracerOptions, } from "./workflows";
+import { AIEvalClient } from "./client";
+export default AIEvalClient;

package/dist/index.js

@@ -0,0 +1,153 @@
+"use strict";
+/**
+ * EvalGate SDK
+ *
+ * Official TypeScript/JavaScript SDK for EvalGate.
+ * Build confidence in your AI systems with comprehensive evaluation tools.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTestSuite = exports.SpecRegistrationError = exports.SpecExecutionError = exports.RuntimeError = exports.EvalRuntimeError = exports.setActiveRuntime = exports.getActiveRuntime = exports.disposeActiveRuntime = exports.createEvalRuntime = exports.defaultLocalExecutor = exports.createLocalExecutor = exports.evalai = exports.defineSuite = exports.defineEval = exports.createResult = exports.createEvalContext = exports.validateContext = exports.mergeContexts = exports.cloneContext = exports.ContextManager = exports.withContext = exports.getContext = exports.createContext = exports.withinRange = exports.similarTo = exports.respondedWithinTime = exports.notContainsPII = exports.matchesSchema = exports.matchesPattern = exports.isValidURL = exports.isValidEmail = exports.hasValidCodeSyntax = exports.hasSentiment = exports.hasReadabilityScore = exports.hasNoToxicity = exports.hasNoHallucinations = exports.hasLength = exports.hasFactualAccuracy = exports.followsInstructions = exports.expect = exports.containsLanguage = exports.containsKeywords = exports.containsJSON = exports.containsAllRequiredFields = exports.NetworkError = exports.ValidationError = exports.AuthenticationError = exports.RateLimitError = exports.EvalGateError = exports.AIEvalClient = void 0;
+exports.WorkflowTracer = exports.traceWorkflowStep = exports.traceLangChainAgent = exports.traceCrewAI = exports.traceAutoGen = exports.createWorkflowTracer = exports.EvaluationTemplates = exports.streamEvaluation = exports.RateLimiter = exports.batchRead = exports.batchProcess = exports.REPORT_SCHEMA_VERSION = exports.GATE_EXIT = exports.GATE_CATEGORY = exports.ARTIFACTS = exports.PaginatedIterator = exports.encodeCursor = exports.decodeCursor = exports.createPaginatedIterator = exports.autoPaginate = exports.extendExpectWithToPassGate = exports.Logger = exports.openAIChatEval = exports.traceOpenAI = exports.traceAnthropic = exports.runCheck = exports.parseArgs = exports.EXIT = exports.RequestCache = exports.CacheTTL = exports.RequestBatcher = exports.importData = exports.exportData = exports.compareSnapshots = exports.saveSnapshot = exports.compareWithSnapshot = exports.snapshot = exports.TestSuite = 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, "AuthenticationError", { enumerable: true, get: function () { return errors_1.AuthenticationError; } });
+Object.defineProperty(exports, "EvalGateError", { enumerable: true, get: function () { return errors_1.EvalGateError; } });
+Object.defineProperty(exports, "NetworkError", { enumerable: true, get: function () { return errors_1.NetworkError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return errors_1.RateLimitError; } });
+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, "containsAllRequiredFields", { enumerable: true, get: function () { return assertions_1.containsAllRequiredFields; } });
+Object.defineProperty(exports, "containsJSON", { enumerable: true, get: function () { return assertions_1.containsJSON; } });
+Object.defineProperty(exports, "containsKeywords", { enumerable: true, get: function () { return assertions_1.containsKeywords; } });
+Object.defineProperty(exports, "containsLanguage", { enumerable: true, get: function () { return assertions_1.containsLanguage; } });
+Object.defineProperty(exports, "expect", { enumerable: true, get: function () { return assertions_1.expect; } });
+Object.defineProperty(exports, "followsInstructions", { enumerable: true, get: function () { return assertions_1.followsInstructions; } });
+Object.defineProperty(exports, "hasFactualAccuracy", { enumerable: true, get: function () { return assertions_1.hasFactualAccuracy; } });
+Object.defineProperty(exports, "hasLength", { enumerable: true, get: function () { return assertions_1.hasLength; } });
+Object.defineProperty(exports, "hasNoHallucinations", { enumerable: true, get: function () { return assertions_1.hasNoHallucinations; } });
+Object.defineProperty(exports, "hasNoToxicity", { enumerable: true, get: function () { return assertions_1.hasNoToxicity; } });
+Object.defineProperty(exports, "hasReadabilityScore", { enumerable: true, get: function () { return assertions_1.hasReadabilityScore; } });
+Object.defineProperty(exports, "hasSentiment", { enumerable: true, get: function () { return assertions_1.hasSentiment; } });
+Object.defineProperty(exports, "hasValidCodeSyntax", { enumerable: true, get: function () { return assertions_1.hasValidCodeSyntax; } });
+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, "matchesPattern", { enumerable: true, get: function () { return assertions_1.matchesPattern; } });
+Object.defineProperty(exports, "matchesSchema", { enumerable: true, get: function () { return assertions_1.matchesSchema; } });
+Object.defineProperty(exports, "notContainsPII", { enumerable: true, get: function () { return assertions_1.notContainsPII; } });
+Object.defineProperty(exports, "respondedWithinTime", { enumerable: true, get: function () { return assertions_1.respondedWithinTime; } });
+Object.defineProperty(exports, "similarTo", { enumerable: true, get: function () { return assertions_1.similarTo; } });
+Object.defineProperty(exports, "withinRange", { enumerable: true, get: function () { return assertions_1.withinRange; } });
+// 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, "ContextManager", { enumerable: true, get: function () { return context_1.EvalContext; } });
+Object.defineProperty(exports, "getContext", { enumerable: true, get: function () { return context_1.getCurrentContext; } });
+Object.defineProperty(exports, "withContext", { enumerable: true, get: function () { return context_1.withContext; } });
+var context_2 = require("./runtime/context");
+Object.defineProperty(exports, "cloneContext", { enumerable: true, get: function () { return context_2.cloneContext; } });
+Object.defineProperty(exports, "mergeContexts", { enumerable: true, get: function () { return context_2.mergeContexts; } });
+Object.defineProperty(exports, "validateContext", { enumerable: true, get: function () { return context_2.validateContext; } });
+// LAYER 1: Runtime Foundation - NEW PROGRAMMING MODEL
+var eval_1 = require("./runtime/eval");
+Object.defineProperty(exports, "createEvalContext", { enumerable: true, get: function () { return eval_1.createContext; } });
+Object.defineProperty(exports, "createResult", { enumerable: true, get: function () { return eval_1.createResult; } });
+Object.defineProperty(exports, "defineEval", { enumerable: true, get: function () { return eval_1.defineEval; } });
+Object.defineProperty(exports, "defineSuite", { enumerable: true, get: function () { return eval_1.defineSuite; } });
+Object.defineProperty(exports, "evalai", { enumerable: true, get: function () { return eval_1.evalai; } });
+var executor_1 = require("./runtime/executor");
+Object.defineProperty(exports, "createLocalExecutor", { enumerable: true, get: function () { return executor_1.createLocalExecutor; } });
+Object.defineProperty(exports, "defaultLocalExecutor", { enumerable: true, get: function () { return executor_1.defaultLocalExecutor; } });
+var registry_1 = require("./runtime/registry");
+Object.defineProperty(exports, "createEvalRuntime", { enumerable: true, get: function () { return registry_1.createEvalRuntime; } });
+Object.defineProperty(exports, "disposeActiveRuntime", { enumerable: true, get: function () { return registry_1.disposeActiveRuntime; } });
+Object.defineProperty(exports, "getActiveRuntime", { enumerable: true, get: function () { return registry_1.getActiveRuntime; } });
+Object.defineProperty(exports, "setActiveRuntime", { enumerable: true, get: function () { return registry_1.setActiveRuntime; } });
+// Runtime errors
+var types_1 = require("./runtime/types");
+Object.defineProperty(exports, "EvalRuntimeError", { enumerable: true, get: function () { return types_1.EvalRuntimeError; } });
+Object.defineProperty(exports, "RuntimeError", { enumerable: true, get: function () { return types_1.RuntimeError; } });
+Object.defineProperty(exports, "SpecExecutionError", { enumerable: true, get: function () { return types_1.SpecExecutionError; } });
+Object.defineProperty(exports, "SpecRegistrationError", { enumerable: true, get: function () { return types_1.SpecRegistrationError; } });
+// Test suite builder (Tier 2.7) - BACKWARD COMPATIBILITY LAYER
+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, "compareWithSnapshot", { enumerable: true, get: function () { return snapshot_1.compareWithSnapshot; } });
+Object.defineProperty(exports, "compareSnapshots", { enumerable: true, get: function () { return snapshot_1.compareWithSnapshot; } });
+Object.defineProperty(exports, "snapshot", { enumerable: true, get: function () { return snapshot_1.snapshot; } });
+Object.defineProperty(exports, "saveSnapshot", { enumerable: true, get: function () { return snapshot_1.snapshot; } });
+// 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; } });
+// 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; } });
+// 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, "CacheTTL", { enumerable: true, get: function () { return cache_1.CacheTTL; } });
+Object.defineProperty(exports, "RequestCache", { enumerable: true, get: function () { return cache_1.RequestCache; } });
+// CLI (programmatic use)
+var check_1 = require("./cli/check");
+Object.defineProperty(exports, "EXIT", { enumerable: true, get: function () { return check_1.EXIT; } });
+Object.defineProperty(exports, "parseArgs", { enumerable: true, get: function () { return check_1.parseArgs; } });
+Object.defineProperty(exports, "runCheck", { enumerable: true, get: function () { return check_1.runCheck; } });
+var anthropic_1 = require("./integrations/anthropic");
+Object.defineProperty(exports, "traceAnthropic", { enumerable: true, get: function () { return anthropic_1.traceAnthropic; } });
+// Framework integrations (Tier 1.2)
+var openai_1 = require("./integrations/openai");
+Object.defineProperty(exports, "traceOpenAI", { enumerable: true, get: function () { return openai_1.traceOpenAI; } });
+// OpenAI regression eval (local-first, no account required)
+var openai_eval_1 = require("./integrations/openai-eval");
+Object.defineProperty(exports, "openAIChatEval", { enumerable: true, get: function () { return openai_eval_1.openAIChatEval; } });
+// Debug logger (Tier 4.17)
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
+// Vitest matcher: expect(await openAIChatEval(...)).toPassGate()
+var matchers_1 = require("./matchers");
+Object.defineProperty(exports, "extendExpectWithToPassGate", { enumerable: true, get: function () { return matchers_1.extendExpectWithToPassGate; } });
+var pagination_1 = require("./pagination");
+Object.defineProperty(exports, "autoPaginate", { enumerable: true, get: function () { return pagination_1.autoPaginate; } });
+Object.defineProperty(exports, "createPaginatedIterator", { enumerable: true, get: function () { return pagination_1.createPaginatedIterator; } });
+Object.defineProperty(exports, "decodeCursor", { enumerable: true, get: function () { return pagination_1.decodeCursor; } });
+Object.defineProperty(exports, "encodeCursor", { enumerable: true, get: function () { return pagination_1.encodeCursor; } });
+Object.defineProperty(exports, "PaginatedIterator", { enumerable: true, get: function () { return pagination_1.PaginatedIterator; } });
+// Regression gate constants & types (v1.6.0)
+var regression_1 = require("./regression");
+Object.defineProperty(exports, "ARTIFACTS", { enumerable: true, get: function () { return regression_1.ARTIFACTS; } });
+Object.defineProperty(exports, "GATE_CATEGORY", { enumerable: true, get: function () { return regression_1.GATE_CATEGORY; } });
+Object.defineProperty(exports, "GATE_EXIT", { enumerable: true, get: function () { return regression_1.GATE_EXIT; } });
+Object.defineProperty(exports, "REPORT_SCHEMA_VERSION", { enumerable: true, get: function () { return regression_1.REPORT_SCHEMA_VERSION; } });
+// 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, "batchRead", { enumerable: true, get: function () { return streaming_1.batchRead; } });
+Object.defineProperty(exports, "RateLimiter", { enumerable: true, get: function () { return streaming_1.RateLimiter; } });
+Object.defineProperty(exports, "streamEvaluation", { enumerable: true, get: function () { return streaming_1.streamEvaluation; } });
+// New exports for v1.1.0
+var types_2 = require("./types");
+Object.defineProperty(exports, "EvaluationTemplates", { enumerable: true, get: function () { return types_2.EvaluationTemplates; } });
+// Workflow tracing (Orchestration Layer)
+var workflows_1 = require("./workflows");
+Object.defineProperty(exports, "createWorkflowTracer", { enumerable: true, get: function () { return workflows_1.createWorkflowTracer; } });
+Object.defineProperty(exports, "traceAutoGen", { enumerable: true, get: function () { return workflows_1.traceAutoGen; } });
+Object.defineProperty(exports, "traceCrewAI", { enumerable: true, get: function () { return workflows_1.traceCrewAI; } });
+// Framework integrations
+Object.defineProperty(exports, "traceLangChainAgent", { enumerable: true, get: function () { return workflows_1.traceLangChainAgent; } });
+Object.defineProperty(exports, "traceWorkflowStep", { enumerable: true, get: function () { return workflows_1.traceWorkflowStep; } });
+Object.defineProperty(exports, "WorkflowTracer", { enumerable: true, get: function () { return workflows_1.WorkflowTracer; } });
+// Default export for convenience
+const client_2 = require("./client");
+exports.default = client_2.AIEvalClient;

package/dist/integrations/anthropic.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Anthropic Integration
+ * Tier 1.2: Framework Auto-Instrumentation - Anthropic wrapper
+ *
+ * @example
+ * ```typescript
+ * import { traceAnthropic } from '@ai-eval-platform/sdk/integrations/anthropic';
+ * import Anthropic from '@anthropic-ai/sdk';
+ *
+ * const anthropic = new Anthropic({ apiKey: '...' });
+ * const tracedAnthropic = traceAnthropic(anthropic, client);
+ *
+ * // All calls are automatically traced
+ * const message = await tracedAnthropic.messages.create({
+ *   model: 'claude-3-5-sonnet-20241022',
+ *   max_tokens: 1024,
+ *   messages: [{ role: 'user', content: 'Hello!' }]
+ * });
+ * ```
+ */
+import type { AIEvalClient } from "../client";
+interface AnthropicMessageParams {
+    model: string;
+    messages: unknown[];
+    temperature?: number;
+    max_tokens?: number;
+    [key: string]: unknown;
+}
+interface AnthropicMessage {
+    content: unknown;
+    usage?: unknown;
+    stop_reason?: unknown;
+    [key: string]: unknown;
+}
+interface AnthropicClient {
+    messages: {
+        create: (params: AnthropicMessageParams, requestOptions?: Record<string, unknown>) => Promise<AnthropicMessage>;
+    };
+}
+export interface AnthropicTraceOptions {
+    /** Whether to capture input (default: true) */
+    captureInput?: boolean;
+    /** Whether to capture output (default: true) */
+    captureOutput?: boolean;
+    /** Whether to capture metadata (default: true) */
+    captureMetadata?: boolean;
+    /** Organization ID for traces */
+    organizationId?: number;
+    /** Custom trace name prefix */
+    tracePrefix?: string;
+}
+/**
+ * Wrap Anthropic client with automatic tracing
+ *
+ * @example
+ * ```typescript
+ * import Anthropic from '@anthropic-ai/sdk';
+ * import { traceAnthropic } from '@ai-eval-platform/sdk/integrations/anthropic';
+ *
+ * const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+ * const tracedAnthropic = traceAnthropic(anthropic, evalClient);
+ *
+ * // Automatically traced
+ * const message = await tracedAnthropic.messages.create({
+ *   model: 'claude-3-5-sonnet-20241022',
+ *   max_tokens: 1024,
+ *   messages: [{ role: 'user', content: 'Hello, Claude!' }]
+ * });
+ * ```
+ */
+export declare function traceAnthropic(anthropic: AnthropicClient, evalClient: AIEvalClient, options?: AnthropicTraceOptions): AnthropicClient;
+/**
+ * Manual trace wrapper for Anthropic calls
+ *
+ * @example
+ * ```typescript
+ * const message = await traceAnthropicCall(
+ *   evalClient,
+ *   'claude-completion',
+ *   async () => {
+ *     return await anthropic.messages.create({
+ *       model: 'claude-3-5-sonnet-20241022',
+ *       max_tokens: 1024,
+ *       messages: [{ role: 'user', content: 'Hello!' }]
+ *     });
+ *   }
+ * );
+ * ```
+ */
+export declare function traceAnthropicCall<T>(evalClient: AIEvalClient, name: string, fn: () => Promise<T>, options?: AnthropicTraceOptions): Promise<T>;
+export {};