evalite/dist/db.d.ts

Test your LLM-powered apps with a TypeScript-native, Vitest-based eval runner. No API key required.

import type * as BetterSqlite3 from "better-sqlite3";
import type { Evalite } from "./types.js";
import type { TaskState } from "vitest";
export type SQLiteDatabase = BetterSqlite3.Database;
export declare const createDatabase: (url: string) => BetterSqlite3.Database;
export declare namespace Db {
    type Run = {
        id: number;
        runType: Evalite.RunType;
        created_at: string;
    };
    type EvalStatus = "fail" | "success" | "running";
    type Eval = {
        id: number;
        run_id: number;
        name: string;
        status: EvalStatus;
        filepath: string;
        duration: number;
        created_at: string;
    };
    type Result = {
        id: number;
        eval_id: number;
        duration: number;
        input: unknown;
        output: unknown;
        expected?: unknown;
        created_at: string;
        col_order: number;
        status: Evalite.ResultStatus;
        rendered_columns?: unknown;
    };
    type Score = {
        id: number;
        result_id: number;
        name: string;
        score: number;
        description?: string;
        metadata?: unknown;
        created_at: string;
    };
    type Trace = {
        id: number;
        result_id: number;
        input: unknown;
        output: unknown;
        start_time: number;
        end_time: number;
        prompt_tokens?: number;
        completion_tokens?: number;
        col_order: number;
    };
}
/**
 * @deprecated
 */
export declare const saveRun: (db: BetterSqlite3.Database, { files, runType, }: {
    runType: Evalite.RunType;
    files: {
        name: string;
        filepath: string;
        tasks: {
            name: string;
            result?: {
                state: TaskState;
            };
            tasks?: {
                name: string;
                result?: {
                    state: TaskState;
                };
                meta: {
                    evalite?: Evalite.TaskMeta;
                };
            }[];
        }[];
    }[];
}) => void;
export interface ResultWithInlineScoresAndTraces extends Db.Result {
    scores: Db.Score[];
    traces: Db.Trace[];
}
interface EvalWithInlineResults extends Db.Eval {
    results: ResultWithInlineScoresAndTraces[];
}
/**
 * @deprecated
 *
 * Used in existing tests, but in future code should be replaced
 * by more specific queries.
 */
export declare const getEvalsAsRecord: (db: SQLiteDatabase) => Promise<Record<string, EvalWithInlineResults[]>>;
export declare const getEvals: (db: BetterSqlite3.Database, runIds: number[], allowedStatuses: Db.EvalStatus[]) => Db.Eval[];
export declare const getResults: (db: BetterSqlite3.Database, evalIds: number[]) => {
    duration: number;
    status: Evalite.ResultStatus;
    id: number;
    eval_id: number;
    created_at: string;
    col_order: number;
    input: unknown;
    expected: unknown;
    output: unknown;
    rendered_columns: unknown;
}[];
export declare const getScores: (db: BetterSqlite3.Database, resultIds: number[]) => {
    name: string;
    description?: string | undefined;
    score: number;
    id: number;
    created_at: string;
    result_id: number;
    metadata: unknown;
}[];
export declare const getTraces: (db: BetterSqlite3.Database, resultIds: number[]) => {
    id: number;
    col_order: number;
    result_id: number;
    start_time: number;
    end_time: number;
    prompt_tokens?: number | undefined;
    completion_tokens?: number | undefined;
    input: unknown;
    output: unknown;
}[];
export declare const getMostRecentRun: (db: BetterSqlite3.Database, runType: Evalite.RunType) => Db.Run | undefined;
export declare const getPreviousCompletedEval: (db: BetterSqlite3.Database, name: string, startTime: string) => Db.Eval | undefined;
export declare const getAverageScoresFromResults: (db: BetterSqlite3.Database, resultIds: number[]) => {
    result_id: number;
    average: number;
}[];
export declare const getEvalsAverageScores: (db: BetterSqlite3.Database, evalIds: number[]) => {
    eval_id: number;
    average: number;
}[];
type Prettify<T> = {
    [K in keyof T]: T[K];
} & {};
export declare const jsonParseFields: <T extends object, K extends keyof T>(obj: T, fields: K[]) => Prettify<Omit<T, K> & Record<K, unknown>>;
/**
 * Defaults to most recent if timestamp not passed
 */
export declare const getEvalByName: (db: BetterSqlite3.Database, opts: {
    name: string;
    timestamp?: string;
    statuses?: Db.EvalStatus[];
}) => Db.Eval | undefined;
export declare const getHistoricalEvalsWithScoresByName: (db: BetterSqlite3.Database, name: string) => (Db.Eval & {
    average_score: number;
})[];
export declare const createEvalIfNotExists: ({ db, runId, name, filepath, }: {
    db: SQLiteDatabase;
    runId: number | bigint;
    name: string;
    filepath: string;
}) => number | bigint;
export declare const createRun: ({ db, runType, }: {
    db: SQLiteDatabase;
    runType: Evalite.RunType;
}) => number | bigint;
export declare const insertResult: ({ db, evalId, order, input, expected, output, duration, status, renderedColumns, }: {
    db: SQLiteDatabase;
    evalId: number | bigint;
    order: number;
    input: unknown;
    expected: unknown;
    output: unknown;
    duration: number;
    status: string;
    renderedColumns: unknown;
}) => number | bigint;
export declare const updateResult: ({ db, resultId, output, duration, status, renderedColumns, input, expected, }: {
    db: SQLiteDatabase;
    resultId: number | bigint;
    output: unknown;
    duration: number;
    input: unknown;
    expected: unknown;
    status: string;
    renderedColumns: unknown;
}) => void;
export declare const insertScore: ({ db, resultId, description, name, score, metadata, }: {
    db: SQLiteDatabase;
    resultId: number | bigint;
    description: string | undefined;
    name: string;
    score: number;
    metadata: unknown;
}) => void;
export declare const insertTrace: ({ db, resultId, input, output, start, end, promptTokens, completionTokens, order, }: {
    db: SQLiteDatabase;
    resultId: number | bigint;
    input: unknown;
    output: unknown;
    start: number;
    end: number;
    promptTokens: number | undefined;
    completionTokens: number | undefined;
    order: number;
}) => void;
export declare const updateEvalStatusAndDuration: ({ db, evalId, status, }: {
    db: SQLiteDatabase;
    evalId: number | bigint;
    status: Db.EvalStatus;
}) => void;
export declare const findResultByEvalIdAndOrder: ({ db, evalId, order, }: {
    db: SQLiteDatabase;
    evalId: number | bigint;
    order: number;
}) => number | undefined;
export declare const getAllResultsForEval: ({ db, evalId, }: {
    db: SQLiteDatabase;
    evalId: number | bigint;
}) => Array<{
    id: number;
    status: Evalite.ResultStatus;
}>;
export {};
//# sourceMappingURL=db.d.ts.map