deepeval 0.1.17

package/dist/confident/evaluate.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluate = evaluate;
+const api_1 = require("./api");
+const utils_1 = require("../utils");
+const prompt_1 = require("../prompt");
+function convertTurn(turn) {
+    const toolsCalled = turn.toolsCalled
+        ? turn.toolsCalled.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            reasoning: tool.reasoning,
+            output: tool.output,
+            inputParameters: tool.inputParameters,
+        }))
+        : undefined;
+    return {
+        role: turn.role,
+        content: turn.content,
+        userId: turn.userId,
+        retrievalContext: turn.retrievalContext,
+        toolsCalled: toolsCalled,
+        additionalMetadata: turn.additionalMetadata,
+    };
+}
+function convertLLMTestCase(testCase) {
+    const toolsCalled = testCase.toolsCalled
+        ? testCase.toolsCalled.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            reasoning: tool.reasoning,
+            output: tool.output,
+            inputParameters: tool.inputParameters,
+        }))
+        : undefined;
+    const expectedTools = testCase.expectedTools
+        ? testCase.expectedTools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            reasoning: tool.reasoning,
+            output: tool.output,
+            inputParameters: tool.inputParameters,
+        }))
+        : undefined;
+    return {
+        input: testCase.input,
+        actualOutput: testCase.actualOutput,
+        expectedOutput: testCase.expectedOutput,
+        context: testCase.context,
+        retrievalContext: testCase.retrievalContext,
+        additionalMetadata: testCase.additionalMetadata,
+        comments: testCase.comments,
+        toolsCalled: toolsCalled,
+        expectedTools: expectedTools,
+        reasoning: testCase.reasoning,
+        tokenCost: testCase.tokenCost,
+        completionTime: testCase.completionTime,
+        name: testCase.name,
+    };
+}
+function convertConversationalTestCase(testCase) {
+    const turns = testCase.turns.map(convertTurn);
+    return {
+        turns: turns,
+        scenario: testCase.scenario || undefined,
+        expectedOutcome: testCase.expectedOutcome || undefined,
+        userDescription: testCase.userDescription || undefined,
+        chatbotRole: testCase.chatbotRole || undefined,
+    };
+}
+async function processHyperparameters(hyperparameters) {
+    const processed = {};
+    for (const [key, value] of Object.entries(hyperparameters)) {
+        if (value instanceof prompt_1.Prompt) {
+            try {
+                if (!value.hash || value.hash === "latest" || !value.type) {
+                    await value.push();
+                }
+                processed[key] = {
+                    id: value.hash,
+                    type: value.type || (value.textTemplate !== null ? "TEXT" : "LIST"),
+                };
+            }
+            catch (e) {
+                console.warn(`Failed to process prompt hyperparameter '${key}':`, e);
+                processed[key] = "Error processing prompt";
+            }
+        }
+        else {
+            processed[key] = String(value);
+        }
+    }
+    return processed;
+}
+async function evaluate(params) {
+    const { metricCollection, llmTestCases, conversationalTestCases, hyperparameters, identifier, } = params;
+    /////////////////////////////////////////////////////////
+    /// Type Checking
+    /////////////////////////////////////////////////////////
+    if ((llmTestCases?.length ?? 0) === 0 &&
+        (conversationalTestCases?.length ?? 0) === 0) {
+        throw new Error("You must provide either a non-empty array of 'llmTestCases' or 'conversationalTestCases'");
+    }
+    const testCaseLength = (llmTestCases?.length ?? 0) + (conversationalTestCases?.length ?? 0);
+    ////////////////////////////////////////////////////////
+    /// Posting Data
+    /////////////////////////////////////////////////////////
+    if ((0, utils_1.isConfident)()) {
+        console.log(`Sending ${testCaseLength} test case(s) to Confident AI...`);
+        const startTime = performance.now();
+        try {
+            const api = new api_1.Api(undefined, api_1.API_BASE_URL);
+            let processedHyperparameters;
+            if (hyperparameters) {
+                processedHyperparameters = await processHyperparameters(hyperparameters);
+            }
+            let confidentRequestData;
+            if (llmTestCases) {
+                const convertedTestCases = llmTestCases.map(convertLLMTestCase);
+                confidentRequestData = {
+                    metricCollection,
+                    llmTestCases: convertedTestCases,
+                    hyperparameters: processedHyperparameters,
+                    identifier,
+                };
+            }
+            else if (conversationalTestCases) {
+                const convertedTestCases = conversationalTestCases.map(convertConversationalTestCase);
+                confidentRequestData = {
+                    metricCollection,
+                    conversationalTestCases: convertedTestCases,
+                    hyperparameters: processedHyperparameters,
+                    identifier,
+                };
+            }
+            else {
+                throw new Error("You must provide either a non-empty array of 'llmTestCases' or 'conversationalTestCases'");
+            }
+            const result = await api.sendRequest(api_1.HttpMethods.POST, api_1.Endpoints.EVALUATE_ENDPOINT, confidentRequestData);
+            const endTime = performance.now();
+            const timeTaken = ((endTime - startTime) / 1000).toFixed(2);
+            if (result) {
+                const response = {
+                    link: result.link,
+                };
+                console.log(`Done! (${timeTaken}s)`);
+                console.log(`✓ Evaluation of metric collection '${metricCollection}' started! View progress on ${response.link}`);
+            }
+        }
+        catch (error) {
+            const endTime = performance.now();
+            const timeTaken = ((endTime - startTime) / 1000).toFixed(2);
+            console.error(`Error! (${timeTaken}s)`);
+            throw error;
+        }
+    }
+    else {
+        throw new Error("To run evaluations on Confident AI, run `deepeval login`.");
+    }
+}

package/dist/confident/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Exports for the confident module
+ */
+export * from "./api";
+export * from "./types";
+export { evaluate } from "./evaluate";

package/dist/confident/index.js

@@ -0,0 +1,24 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluate = void 0;
+/**
+ * Exports for the confident module
+ */
+__exportStar(require("./api"), exports);
+__exportStar(require("./types"), exports);
+var evaluate_1 = require("./evaluate");
+Object.defineProperty(exports, "evaluate", { enumerable: true, get: function () { return evaluate_1.evaluate; } });

package/dist/confident/types.d.ts

@@ -0,0 +1,13 @@
+import { ConversationalTestCase, LLMTestCase } from "../test-case";
+export interface ConfidentEvaluateRequestData {
+    metricCollection: string;
+    llmTestCases?: LLMTestCase[];
+    conversationalTestCases?: ConversationalTestCase[];
+    hyperparameters?: {
+        [key: string]: string;
+    };
+    identifier?: string;
+}
+export interface ConfidentEvaluateResponseData {
+    link: string;
+}

package/dist/confident/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/config/settings.d.ts

@@ -0,0 +1,11 @@
+import { Environment } from "../tracing/utils";
+export interface Settings {
+    CONFIDENT_TRACE_ENVIRONMENT?: Environment;
+    CONFIDENT_TRACE_VERBOSE?: boolean;
+    CONFIDENT_TRACE_SAMPLE_RATE?: number;
+    CONFIDENT_OTEL_URL?: string;
+}
+export declare function getSettings(): Settings;
+export declare function resetSettings({ reloadDotenv, }?: {
+    reloadDotenv?: boolean;
+}): Settings;

package/dist/config/settings.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSettings = getSettings;
+exports.resetSettings = resetSettings;
+const utils_1 = require("../tracing/utils");
+let _settings_singleton = null;
+function getSettings() {
+    if (_settings_singleton === null) {
+        _settings_singleton = {
+            CONFIDENT_TRACE_ENVIRONMENT: process.env.CONFIDENT_TRACE_ENVIRONMENT ||
+                utils_1.Environment.DEVELOPMENT,
+            CONFIDENT_TRACE_VERBOSE: process.env.CONFIDENT_TRACE_VERBOSE !== undefined
+                ? ["yes", "true", "1"].includes(process.env.CONFIDENT_TRACE_VERBOSE.toLowerCase())
+                : true,
+            CONFIDENT_TRACE_SAMPLE_RATE: process.env.CONFIDENT_TRACE_SAMPLE_RATE !== undefined
+                ? parseFloat(process.env.CONFIDENT_TRACE_SAMPLE_RATE)
+                : 1.0,
+            CONFIDENT_OTEL_URL: process.env.CONFIDENT_OTEL_URL ||
+                "https://otel.confident-ai.com",
+        };
+    }
+    return _settings_singleton;
+}
+function resetSettings({ reloadDotenv = false, } = {}) {
+    if (reloadDotenv) {
+        // TODO
+    }
+    _settings_singleton = null;
+    return getSettings();
+}

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const CONFIDENT_TRACE_VERBOSE = "CONFIDENT_TRACE_VERBOSE";
+export declare const CONFIDENT_TRACE_SAMPLE_RATE = "CONFIDENT_TRACE_SAMPLE_RATE";
+export declare const CONFIDENT_TRACE_ENVIRONMENT = "CONFIDENT_TRACE_ENVIRONMENT";
+export declare const CONFIDENT_TRACING_ENABLED = "CONFIDENT_TRACING_ENABLED";

package/dist/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIDENT_TRACING_ENABLED = exports.CONFIDENT_TRACE_ENVIRONMENT = exports.CONFIDENT_TRACE_SAMPLE_RATE = exports.CONFIDENT_TRACE_VERBOSE = void 0;
+exports.CONFIDENT_TRACE_VERBOSE = "CONFIDENT_TRACE_VERBOSE";
+exports.CONFIDENT_TRACE_SAMPLE_RATE = "CONFIDENT_TRACE_SAMPLE_RATE";
+exports.CONFIDENT_TRACE_ENVIRONMENT = "CONFIDENT_TRACE_ENVIRONMENT";
+exports.CONFIDENT_TRACING_ENABLED = "CONFIDENT_TRACING_ENABLED";

package/dist/dataset/api.d.ts

@@ -0,0 +1,15 @@
+import { ConversationalGolden, Golden } from "./golden";
+export interface APIDataset {
+    alias: string;
+    overwrite?: boolean;
+    goldens?: Golden[];
+    conversationalGoldens?: any[];
+}
+export interface CreateDatasetHttpResponse {
+    link: string;
+}
+export interface DatasetHttpResponse {
+    goldens: Golden[];
+    conversationalGoldens: ConversationalGolden[];
+    id: string;
+}

package/dist/dataset/api.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/dataset/dataset.d.ts

@@ -0,0 +1,54 @@
+import { ConversationalGolden, Golden } from "./golden";
+import { ConversationalTestCase, LLMTestCase } from "../test-case";
+export type GoldenUnion = Golden | ConversationalGolden;
+export type GoldenUnionArray = Golden[] | ConversationalGolden[];
+export type TestCaseUnion = LLMTestCase | ConversationalTestCase;
+export type TestCaseUnionArray = LLMTestCase[] | ConversationalTestCase[];
+export declare class EvaluationDataset {
+    private _multiTurn;
+    private _alias;
+    private _id;
+    private _goldens;
+    private _conversationalGoldens;
+    private _llmTestCases;
+    private _conversationalTestCases;
+    constructor(params?: {
+        goldens?: GoldenUnionArray;
+    });
+    toString(): string;
+    get goldens(): GoldenUnionArray;
+    set goldens(goldens: GoldenUnionArray);
+    addGolden(golden: GoldenUnion): void;
+    private _addGolden;
+    private _addConversationalGolden;
+    get testCases(): TestCaseUnionArray;
+    set testCases(testCases: TestCaseUnionArray);
+    addTestCase(testCase: TestCaseUnion): void;
+    pull(params: {
+        alias: string;
+        finalized?: boolean;
+        autoConvertGoldensToTestCases?: boolean;
+    }): Promise<void>;
+    push(params: {
+        alias: string;
+        overwrite?: boolean;
+    }): Promise<void>;
+    queue(params: {
+        alias: string;
+        goldens: Array<Golden | ConversationalGolden>;
+        printResponse?: boolean;
+    }): Promise<void>;
+    addTestCasesFromCSV({ filePath, inputCol, actualOutputCol, expectedOutputCol, contextCol, contextDelimiter, retrievalContextCol, retrievalContextDelimiter, toolsCalledCol, expectedToolsCol, additionalMetadataCol, }: {
+        filePath: string;
+        inputCol: string;
+        actualOutputCol: string;
+        expectedOutputCol?: string;
+        contextCol?: string;
+        contextDelimiter?: string;
+        retrievalContextCol?: string;
+        retrievalContextDelimiter?: string;
+        toolsCalledCol?: string;
+        expectedToolsCol?: string;
+        additionalMetadataCol?: string;
+    }): Promise<any>;
+}

package/dist/dataset/dataset.js

@@ -0,0 +1,289 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluationDataset = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const papaparse_1 = __importDefault(require("papaparse"));
+const utils_1 = require("./utils");
+const utils_2 = require("../utils");
+const api_1 = require("../confident/api");
+const golden_1 = require("./golden");
+const test_case_1 = require("../test-case");
+class EvaluationDataset {
+    _multiTurn = null;
+    _alias = null;
+    _id = null;
+    _goldens = [];
+    _conversationalGoldens = [];
+    _llmTestCases = [];
+    _conversationalTestCases = [];
+    constructor(params = {}) {
+        this._alias = null;
+        this._id = null;
+        const goldens = params.goldens ?? [];
+        if (goldens.length > 0) {
+            this._multiTurn = goldens[0] instanceof golden_1.ConversationalGolden;
+        }
+        this._goldens = [];
+        this._conversationalGoldens = [];
+        for (const golden of goldens) {
+            golden._datasetRank = goldens.length;
+            if (this._multiTurn) {
+                this._addConversationalGolden(golden);
+            }
+            else {
+                this._addGolden(golden);
+            }
+        }
+        this._llmTestCases = [];
+        this._conversationalTestCases = [];
+    }
+    toString() {
+        return `${this.constructor.name}(test_cases=${JSON.stringify(this.testCases)}, goldens=${JSON.stringify(this.goldens)}, _alias=${this._alias}, _id=${this._id}, _multi_turn=${this._multiTurn})`;
+    }
+    ////////////////////////////////////////////////////////
+    // Golden Properties
+    ////////////////////////////////////////////////////////
+    get goldens() {
+        return this._multiTurn ? this._conversationalGoldens : this._goldens;
+    }
+    set goldens(goldens) {
+        const prevGoldens = this._goldens;
+        const prevConvGoldens = this._conversationalGoldens;
+        this._goldens = [];
+        this._conversationalGoldens = [];
+        try {
+            for (const golden of goldens) {
+                if (!(golden instanceof golden_1.Golden) &&
+                    !(golden instanceof golden_1.ConversationalGolden)) {
+                    throw new TypeError("Your goldens must be instances of either ConversationalGolden or Golden");
+                }
+                golden._datasetAlias = this._alias ?? undefined;
+                golden._datasetId = this._id ?? undefined;
+                golden._datasetRank = goldens.length;
+                if (this._multiTurn) {
+                    this._addConversationalGolden(golden);
+                }
+                else {
+                    this.addGolden(golden);
+                }
+            }
+        }
+        catch (e) {
+            this._goldens = prevGoldens;
+            this._conversationalGoldens = prevConvGoldens;
+            throw e;
+        }
+    }
+    addGolden(golden) {
+        if (this._multiTurn === null) {
+            this._multiTurn = golden instanceof golden_1.ConversationalGolden;
+        }
+        if (this._multiTurn) {
+            this._addConversationalGolden(golden);
+        }
+        else {
+            this._addGolden(golden);
+        }
+    }
+    _addGolden(golden) {
+        if (golden instanceof golden_1.Golden) {
+            this._goldens.push(golden);
+        }
+        else {
+            throw new TypeError("You cannot add a multi-turn ConversationalGolden to a single-turn dataset. You can only add a Golden.");
+        }
+    }
+    _addConversationalGolden(golden) {
+        if (golden instanceof golden_1.ConversationalGolden) {
+            this._conversationalGoldens.push(golden);
+        }
+        else {
+            throw new TypeError("You cannot add a single-turn Golden to a multi-turn dataset. You can only add a ConversationalGolden.");
+        }
+    }
+    ////////////////////////////////////////////////////////
+    // Test Case Properties
+    ////////////////////////////////////////////////////////
+    get testCases() {
+        return this._multiTurn ? this._conversationalTestCases : this._llmTestCases;
+    }
+    set testCases(testCases) {
+        const llmTestCases = [];
+        const conversationalTestCases = [];
+        for (const testCase of testCases) {
+            if (!(testCase instanceof test_case_1.LLMTestCase) &&
+                !(testCase instanceof test_case_1.ConversationalTestCase)) {
+                continue;
+            }
+            testCase._datasetAlias = this._alias ?? undefined;
+            testCase._datasetId = this._id ?? undefined;
+            if (testCase instanceof test_case_1.LLMTestCase) {
+                testCase._datasetRank = llmTestCases.length;
+                llmTestCases.push(testCase);
+            }
+            else if (testCase instanceof test_case_1.ConversationalTestCase) {
+                testCase._datasetRank = conversationalTestCases.length;
+                conversationalTestCases.push(testCase);
+            }
+        }
+        this._llmTestCases = llmTestCases;
+        this._conversationalTestCases = conversationalTestCases;
+    }
+    addTestCase(testCase) {
+        testCase._datasetAlias = this._alias ?? undefined;
+        testCase._datasetId = this._id ?? undefined;
+        if (testCase instanceof test_case_1.LLMTestCase) {
+            testCase._datasetRank = this._llmTestCases.length;
+            this._llmTestCases.push(testCase);
+        }
+        else if (testCase instanceof test_case_1.ConversationalTestCase) {
+            testCase._datasetRank = this._conversationalTestCases.length;
+            this._conversationalTestCases.push(testCase);
+        }
+    }
+    ////////////////////////////////////////////////////////
+    // Push and Pull Methods
+    ////////////////////////////////////////////////////////
+    async pull(params) {
+        const { alias, finalized = true, autoConvertGoldensToTestCases = false, } = params;
+        if (!(0, utils_2.isConfident)()) {
+            throw new Error("Set CONFIDENT_API_KEY to pull dataset.");
+        }
+        console.log(`Pulling '${alias}' from Confident AI...`);
+        const api = new api_1.Api();
+        const startTime = performance.now();
+        const result = await api.sendRequest(api_1.HttpMethods.GET, api_1.Endpoints.DATASET_ENDPOINT, undefined, { alias, finalized: finalized.toString().toLowerCase() });
+        const response = {
+            goldens: result.goldens
+                ? result.goldens.map((goldenData) => new golden_1.Golden({
+                    input: goldenData.input,
+                    actualOutput: goldenData.actualOutput,
+                    expectedOutput: goldenData.expectedOutput,
+                    context: goldenData.context,
+                    retrievalContext: goldenData.retrievalContext,
+                    toolsCalled: goldenData.toolsCalled,
+                    expectedTools: goldenData.expectedTools,
+                    additionalMetadata: goldenData.additionalMetadata,
+                    sourceFile: goldenData.sourceFile,
+                    comments: goldenData.comments,
+                }))
+                : undefined,
+            conversationalGoldens: result.conversationalGoldens
+                ? result.conversationalGoldens.map((goldenData) => new golden_1.ConversationalGolden({
+                    scenario: goldenData.scenario,
+                    expectedOutcome: goldenData.expectedOutcome,
+                    userDescription: goldenData.userDescription,
+                    context: goldenData.context,
+                    additionalMetadata: goldenData.additionalMetadata,
+                    comments: goldenData.comments,
+                    name: goldenData.name,
+                    customColumnKeyValues: goldenData.customColumnKeyValues,
+                    turns: goldenData.turns,
+                    _datasetRank: goldenData._datasetRank,
+                    _datasetAlias: goldenData._datasetAlias,
+                    _datasetId: goldenData._datasetId,
+                }))
+                : undefined,
+            id: result.datasetId,
+        };
+        this._alias = alias;
+        this._id = response.id;
+        this._multiTurn = result.goldens === undefined;
+        this.goldens = [];
+        this.testCases = [];
+        if (autoConvertGoldensToTestCases) {
+            if (!this._multiTurn) {
+                const llmTestCases = (0, utils_1.convertGoldensToTestCases)(response.goldens, alias, response.id);
+                this._llmTestCases.push(...llmTestCases);
+            }
+            else {
+                const conversationalTestCases = (0, utils_1.convertConvoGoldensToConvoTestCases)(response.conversationalGoldens, alias, response.id);
+                this._conversationalTestCases.push(...conversationalTestCases);
+            }
+        }
+        else {
+            if (!this._multiTurn) {
+                this.goldens = response.goldens;
+            }
+            else {
+                this.goldens = response.conversationalGoldens;
+                for (const golden of this.goldens) {
+                    golden._datasetAlias = alias;
+                    golden._datasetId = response.id;
+                }
+            }
+        }
+        const endTime = performance.now();
+        const timeTaken = ((endTime - startTime) / 1000).toFixed(2);
+        console.log(`Done! (${timeTaken}s)`);
+    }
+    async push(params) {
+        const { alias, overwrite = false } = params;
+        if (this.goldens.length === 0) {
+            throw new Error("Unable to push empty dataset to Confident AI, there must be at least one golden in dataset.");
+        }
+        const api = new api_1.Api();
+        const apiDataset = {
+            alias,
+            overwrite,
+            goldens: !this._multiTurn ? this.goldens : undefined,
+            conversationalGoldens: this._multiTurn ? this.goldens : undefined,
+        };
+        const body = (0, utils_1.stripPrivateFields)(JSON.parse(JSON.stringify(apiDataset)));
+        console.log(`Pushing '${alias}' to Confident AI...`);
+        const result = await api.sendRequest(api_1.HttpMethods.POST, api_1.Endpoints.DATASET_ENDPOINT, body);
+        const link = result?.link;
+        if (link) {
+            console.log(`✅ Dataset successfully pushed to Confident AI! View at: ${link}`);
+        }
+    }
+    ////////////////////////////////////////////////////////
+    // Queue Methods
+    ////////////////////////////////////////////////////////
+    async queue(params) {
+        const { alias, goldens, printResponse = true } = params;
+        if (!goldens || goldens.length === 0) {
+            throw new Error(`Can't queue empty list of goldens to dataset with alias: ${alias} on Confident AI.`);
+        }
+        const api = new api_1.Api();
+        const isMultiTurn = goldens[0] instanceof golden_1.ConversationalGolden;
+        const apiDataset = {
+            alias,
+            goldens: !isMultiTurn ? goldens : undefined,
+            conversationalGoldens: isMultiTurn ? goldens : undefined,
+        };
+        const body = (0, utils_1.stripPrivateFields)(apiDataset);
+        console.log(`Queueing ${goldens.length} golden(s) to '${alias}' on Confident AI...`);
+        const result = await api.sendRequest(api_1.HttpMethods.POST, api_1.Endpoints.DATASET_ENDPOINT, body, undefined, `/v1/datasets/${alias}/queue`);
+        const link = result?.link;
+        if (link && printResponse) {
+            console.log(`✅ Goldens successfully queued to Confident AI! Annotate & finalize at: ${link}`);
+        }
+    }
+    async addTestCasesFromCSV({ filePath, inputCol, actualOutputCol, expectedOutputCol, contextCol, contextDelimiter = ";", retrievalContextCol, retrievalContextDelimiter = ";", toolsCalledCol, expectedToolsCol, additionalMetadataCol, }) {
+        const csvData = node_fs_1.default.readFileSync(filePath, "utf8");
+        const { data, errors } = papaparse_1.default.parse(csvData, {
+            header: true,
+            skipEmptyLines: true,
+        });
+        if (errors.length) {
+            throw new Error(`CSV parse error: ${errors[0].message}`);
+        }
+        return data.map((row) => new test_case_1.LLMTestCase({
+            input: row[inputCol],
+            actualOutput: row[actualOutputCol],
+            expectedOutput: expectedOutputCol
+                ? row[expectedOutputCol]
+                : undefined,
+            context: (0, utils_1.parseDelimited)(row[contextCol], contextDelimiter),
+            retrievalContext: (0, utils_1.parseDelimited)(row[retrievalContextCol], retrievalContextDelimiter),
+            toolsCalled: (0, utils_1.safeJsonParse)(row[toolsCalledCol], []),
+            expectedTools: (0, utils_1.safeJsonParse)(row[expectedToolsCol], []),
+            additionalMetadata: (0, utils_1.safeJsonParse)(row[additionalMetadataCol], undefined),
+        }));
+    }
+}
+exports.EvaluationDataset = EvaluationDataset;