peerbench 0.0.1 → 0.0.2-alpha.0

package/dist/benchmarks/index.d.ts

@@ -0,0 +1,1698 @@
+import { a as GenericJSONArrayDataLoader } from '../generic-array-DLHWSvf1.js';
+import { I as IdGenerator } from '../index-WiPjF2AL.js';
+import * as z from 'zod';
+import z__default, { z as z$1 } from 'zod';
+import { A as AbstractLLMProvider } from '../llm-DNj_tp2T.js';
+import { a as MCQScorer, L as LLMJudgeScorer } from '../llm-judge-DIG1f1Az.js';
+import { a as SimpleSystemPromptV1 } from '../simple-system-prompt-CzPYuvo0.js';
+import { c as RunnerResult, A as AbstractDataLoader, L as LoaderResult } from '../data-BmN5WjZ4.js';
+import * as zod_v4_core from 'zod/v4/core';
+import { A as AbstractScorer, B as BaseScorerResult } from '../abstract-Dec9Sc5O.js';
+import '../schemas/index.js';
+import '../provider-BDjGp2y-.js';
+import 'openai/resources/shared';
+import 'openai/resources/chat/completions';
+import '../rate-limiter-CSmVIRsM.js';
+import '../system-prompt--0FdPWqK.js';
+
+declare const PeerbenchMultipleChoiceTestCaseSchemaV1: z$1.ZodObject<Omit<{
+    id: z$1.ZodString;
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+    metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+}, "kind" | "schemaVersion"> & {
+    question: z$1.ZodString;
+    options: z$1.ZodRecord<z$1.ZodString, z$1.ZodString>;
+    answer: z$1.ZodString;
+    answerKey: z$1.ZodString;
+} & {
+    kind: z$1.ZodLiteral<"pb.ts.mcq">;
+    schemaVersion: z$1.ZodLiteral<1>;
+}, z$1.core.$strip> & {
+    new: (input: Omit<{
+        id: string;
+        question: string;
+        options: Record<string, string>;
+        answer: string;
+        answerKey: string;
+        kind: "pb.ts.mcq";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    }, "kind" | "schemaVersion">) => {
+        id: string;
+        question: string;
+        options: Record<string, string>;
+        answer: string;
+        answerKey: string;
+        kind: "pb.ts.mcq";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    };
+    newWithId(input: Omit<{
+        id: string;
+        question: string;
+        options: Record<string, string>;
+        answer: string;
+        answerKey: string;
+        kind: "pb.ts.mcq";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+        id: string;
+        question: string;
+        options: Record<string, string>;
+        answer: string;
+        answerKey: string;
+        kind: "pb.ts.mcq";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    }>;
+};
+type PeerbenchMultipleChoiceTestCaseV1 = z$1.infer<typeof PeerbenchMultipleChoiceTestCaseSchemaV1>;
+declare const PeerbenchMultipleChoiceResponseSchemaV1: z$1.ZodObject<Omit<Omit<{
+    id: z$1.ZodString;
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+    startedAt: z$1.ZodNumber;
+    completedAt: z$1.ZodNumber;
+    testCaseId: z$1.ZodString;
+    metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+}, "kind" | "schemaVersion"> & {
+    data: z$1.ZodString;
+    modelSlug: z$1.ZodString;
+    provider: z$1.ZodString;
+    systemPromptId: z$1.ZodOptional<z$1.ZodString>;
+    inputTokensUsed: z$1.ZodOptional<z$1.ZodNumber>;
+    outputTokensUsed: z$1.ZodOptional<z$1.ZodNumber>;
+    inputCost: z$1.ZodOptional<z$1.ZodString>;
+    outputCost: z$1.ZodOptional<z$1.ZodString>;
+} & {
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+}, "kind" | "schemaVersion"> & {
+    kind: z$1.ZodLiteral<"pb.rs.mcq">;
+    schemaVersion: z$1.ZodLiteral<1>;
+}, z$1.core.$strip> & {
+    new: (input: Omit<{
+        id: string;
+        testCaseId: string;
+        startedAt: number;
+        completedAt: number;
+        data: string;
+        provider: string;
+        modelSlug: string;
+        kind: "pb.rs.mcq";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+        systemPromptId?: string | undefined;
+    }, "kind" | "schemaVersion">) => {
+        id: string;
+        testCaseId: string;
+        startedAt: number;
+        completedAt: number;
+        data: string;
+        provider: string;
+        modelSlug: string;
+        kind: "pb.rs.mcq";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+        systemPromptId?: string | undefined;
+    };
+    newWithId(input: Omit<{
+        id: string;
+        testCaseId: string;
+        startedAt: number;
+        completedAt: number;
+        data: string;
+        provider: string;
+        modelSlug: string;
+        kind: "pb.rs.mcq";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+        systemPromptId?: string | undefined;
+    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+        id: string;
+        testCaseId: string;
+        startedAt: number;
+        completedAt: number;
+        data: string;
+        provider: string;
+        modelSlug: string;
+        kind: "pb.rs.mcq";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+        systemPromptId?: string | undefined;
+    }>;
+};
+type PeerbenchMultipleChoiceResponseV1 = z$1.infer<typeof PeerbenchMultipleChoiceResponseSchemaV1>;
+declare const PeerbenchMultipleChoiceScoreSchemaV1: z$1.ZodObject<Omit<Omit<{
+    id: z$1.ZodString;
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+    value: z$1.ZodNumber;
+    responseId: z$1.ZodString;
+    explanation: z$1.ZodOptional<z$1.ZodString>;
+    metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+    scoringMethod: z$1.ZodEnum<{
+        readonly ai: "ai";
+        readonly human: "human";
+        readonly algo: "algo";
+    }>;
+}, "kind" | "schemaVersion"> & {
+    scorerAIProvider: z$1.ZodOptional<z$1.ZodString>;
+    scorerAIModelSlug: z$1.ZodOptional<z$1.ZodString>;
+    scorerAIInputTokensUsed: z$1.ZodOptional<z$1.ZodNumber>;
+    scorerAIOutputTokensUsed: z$1.ZodOptional<z$1.ZodNumber>;
+    scorerAIInputCost: z$1.ZodOptional<z$1.ZodString>;
+    scorerAIOutputCost: z$1.ZodOptional<z$1.ZodString>;
+} & {
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+}, "kind" | "schemaVersion"> & {
+    extractedAnswers: z$1.ZodArray<z$1.ZodString>;
+} & {
+    kind: z$1.ZodLiteral<"pb.sc.mcq">;
+    schemaVersion: z$1.ZodLiteral<1>;
+}, z$1.core.$strip> & {
+    new: (input: Omit<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        extractedAnswers: string[];
+        kind: "pb.sc.mcq";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    }, "kind" | "schemaVersion">) => {
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        extractedAnswers: string[];
+        kind: "pb.sc.mcq";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    };
+    newWithId(input: Omit<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        extractedAnswers: string[];
+        kind: "pb.sc.mcq";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        extractedAnswers: string[];
+        kind: "pb.sc.mcq";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    }>;
+};
+type PeerbenchMultipleChoiceScoreV1 = z$1.infer<typeof PeerbenchMultipleChoiceScoreSchemaV1>;
+
+declare const PeerbenchOpenEndedTestCaseSchemaV1: z$1.ZodObject<Omit<{
+    id: z$1.ZodString;
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+    metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+}, "kind" | "schemaVersion"> & {
+    question: z$1.ZodString;
+    answer: z$1.ZodOptional<z$1.ZodString>;
+} & {
+    kind: z$1.ZodLiteral<"pb.ts.open-ended">;
+    schemaVersion: z$1.ZodLiteral<1>;
+}, z$1.core.$strip> & {
+    new: (input: Omit<{
+        id: string;
+        question: string;
+        kind: "pb.ts.open-ended";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        answer?: string | undefined;
+    }, "kind" | "schemaVersion">) => {
+        id: string;
+        question: string;
+        kind: "pb.ts.open-ended";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        answer?: string | undefined;
+    };
+    newWithId(input: Omit<{
+        id: string;
+        question: string;
+        kind: "pb.ts.open-ended";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        answer?: string | undefined;
+    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+        id: string;
+        question: string;
+        kind: "pb.ts.open-ended";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        answer?: string | undefined;
+    }>;
+};
+type PeerbenchOpenEndedTestCaseV1 = z$1.infer<typeof PeerbenchOpenEndedTestCaseSchemaV1>;
+declare const PeerbenchOpenEndedResponseSchemaV1: z$1.ZodObject<Omit<Omit<{
+    id: z$1.ZodString;
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+    startedAt: z$1.ZodNumber;
+    completedAt: z$1.ZodNumber;
+    testCaseId: z$1.ZodString;
+    metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+}, "kind" | "schemaVersion"> & {
+    data: z$1.ZodString;
+    modelSlug: z$1.ZodString;
+    provider: z$1.ZodString;
+    systemPromptId: z$1.ZodOptional<z$1.ZodString>;
+    inputTokensUsed: z$1.ZodOptional<z$1.ZodNumber>;
+    outputTokensUsed: z$1.ZodOptional<z$1.ZodNumber>;
+    inputCost: z$1.ZodOptional<z$1.ZodString>;
+    outputCost: z$1.ZodOptional<z$1.ZodString>;
+} & {
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+}, "kind" | "schemaVersion"> & {
+    kind: z$1.ZodLiteral<"pb.rs.open-ended">;
+    schemaVersion: z$1.ZodLiteral<1>;
+}, z$1.core.$strip> & {
+    new: (input: Omit<{
+        id: string;
+        testCaseId: string;
+        startedAt: number;
+        completedAt: number;
+        data: string;
+        provider: string;
+        modelSlug: string;
+        kind: "pb.rs.open-ended";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+        systemPromptId?: string | undefined;
+    }, "kind" | "schemaVersion">) => {
+        id: string;
+        testCaseId: string;
+        startedAt: number;
+        completedAt: number;
+        data: string;
+        provider: string;
+        modelSlug: string;
+        kind: "pb.rs.open-ended";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+        systemPromptId?: string | undefined;
+    };
+    newWithId(input: Omit<{
+        id: string;
+        testCaseId: string;
+        startedAt: number;
+        completedAt: number;
+        data: string;
+        provider: string;
+        modelSlug: string;
+        kind: "pb.rs.open-ended";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+        systemPromptId?: string | undefined;
+    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+        id: string;
+        testCaseId: string;
+        startedAt: number;
+        completedAt: number;
+        data: string;
+        provider: string;
+        modelSlug: string;
+        kind: "pb.rs.open-ended";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+        systemPromptId?: string | undefined;
+    }>;
+};
+type PeerbenchOpenEndedResponseV1 = z$1.infer<typeof PeerbenchOpenEndedResponseSchemaV1>;
+declare const PeerbenchOpenEndedScoreSchemaV1: z$1.ZodObject<Omit<Omit<{
+    id: z$1.ZodString;
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+    value: z$1.ZodNumber;
+    responseId: z$1.ZodString;
+    explanation: z$1.ZodOptional<z$1.ZodString>;
+    metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+    scoringMethod: z$1.ZodEnum<{
+        readonly ai: "ai";
+        readonly human: "human";
+        readonly algo: "algo";
+    }>;
+}, "kind" | "schemaVersion"> & {
+    scorerAIProvider: z$1.ZodOptional<z$1.ZodString>;
+    scorerAIModelSlug: z$1.ZodOptional<z$1.ZodString>;
+    scorerAIInputTokensUsed: z$1.ZodOptional<z$1.ZodNumber>;
+    scorerAIOutputTokensUsed: z$1.ZodOptional<z$1.ZodNumber>;
+    scorerAIInputCost: z$1.ZodOptional<z$1.ZodString>;
+    scorerAIOutputCost: z$1.ZodOptional<z$1.ZodString>;
+} & {
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+}, "kind" | "schemaVersion"> & {
+    kind: z$1.ZodLiteral<"pb.sc.open-ended">;
+    schemaVersion: z$1.ZodLiteral<1>;
+}, z$1.core.$strip> & {
+    new: (input: Omit<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        kind: "pb.sc.open-ended";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    }, "kind" | "schemaVersion">) => {
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        kind: "pb.sc.open-ended";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    };
+    newWithId(input: Omit<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        kind: "pb.sc.open-ended";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        kind: "pb.sc.open-ended";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    }>;
+};
+type PeerbenchOpenEndedScoreV1 = z$1.infer<typeof PeerbenchOpenEndedScoreSchemaV1>;
+
+declare const PeerbenchBenchmarkSpecSchemaV1: z__default.ZodObject<Omit<{
+    kind: z__default.ZodString;
+    schemaVersion: z__default.ZodNumber;
+    metadata: z__default.ZodOptional<z__default.ZodRecord<z__default.ZodString, z__default.ZodUnknown>>;
+}, "kind" | "schemaVersion"> & {
+    /**
+     * Big text contents that can be referred as <text>{key}</text> in a prompt or system prompt.
+     */
+    blobTexts: z__default.ZodOptional<z__default.ZodRecord<z__default.ZodString, z__default.ZodString>>;
+} & {
+    kind: z__default.ZodLiteral<"pb.benchmark.spec">;
+    schemaVersion: z__default.ZodLiteral<1>;
+}, z__default.core.$strip> & {
+    new: (input: Omit<{
+        kind: "pb.benchmark.spec";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        blobTexts?: Record<string, string> | undefined;
+    }, "kind" | "schemaVersion">) => {
+        kind: "pb.benchmark.spec";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        blobTexts?: Record<string, string> | undefined;
+    };
+    newWithId(input: Omit<{
+        kind: "pb.benchmark.spec";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        blobTexts?: Record<string, string> | undefined;
+    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+        kind: "pb.benchmark.spec";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        blobTexts?: Record<string, string> | undefined;
+    }>;
+};
+type PeerbenchBenchmarkSpecV1 = z__default.infer<typeof PeerbenchBenchmarkSpecSchemaV1>;
+
+declare class PeerbenchJSONDataLoader extends GenericJSONArrayDataLoader<PeerbenchMultipleChoiceTestCaseV1 | PeerbenchOpenEndedTestCaseV1, PeerbenchMultipleChoiceResponseV1 | PeerbenchOpenEndedResponseV1, PeerbenchMultipleChoiceScoreV1 | PeerbenchOpenEndedScoreV1> {
+    readonly kind = "pb.load.json.data";
+    loadBenchmarkSpec(params: {
+        content: Uint8Array;
+    }): Promise<PeerbenchBenchmarkSpecV1>;
+    protected testCaseBuilder(data: any): {
+        id: string;
+        question: string;
+        options: Record<string, string>;
+        answer: string;
+        answerKey: string;
+        kind: "pb.ts.mcq";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    } | {
+        id: string;
+        question: string;
+        kind: "pb.ts.open-ended";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        answer?: string | undefined;
+    } | undefined;
+    protected responseBuilder(data: any): Promise<{
+        id: string;
+        testCaseId: string;
+        startedAt: number;
+        completedAt: number;
+        data: string;
+        provider: string;
+        modelSlug: string;
+        kind: "pb.rs.mcq";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+        systemPromptId?: string | undefined;
+    } | {
+        id: string;
+        testCaseId: string;
+        startedAt: number;
+        completedAt: number;
+        data: string;
+        provider: string;
+        modelSlug: string;
+        kind: "pb.rs.open-ended";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+        systemPromptId?: string | undefined;
+    } | undefined>;
+    protected scoreBuilder(data: any): Promise<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        extractedAnswers: string[];
+        kind: "pb.sc.mcq";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    } | {
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        kind: "pb.sc.open-ended";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    } | undefined>;
+}
+
+type ResponseTypes = PeerbenchMultipleChoiceResponseV1 | PeerbenchOpenEndedResponseV1;
+type ScoreTypes = PeerbenchMultipleChoiceScoreV1 | PeerbenchOpenEndedScoreV1;
+type TestCaseTypes = PeerbenchMultipleChoiceTestCaseV1 | PeerbenchOpenEndedTestCaseV1;
+declare function runTestCase$2(params: {
+    testCase: TestCaseTypes;
+    provider: AbstractLLMProvider;
+    scorer?: MCQScorer | LLMJudgeScorer;
+    spec?: PeerbenchBenchmarkSpecV1;
+    runConfig: {
+        model: string;
+        llmJudgeModel?: string;
+    };
+    systemPrompt?: SimpleSystemPromptV1;
+    idGenerators?: {
+        response?: IdGenerator;
+        score?: IdGenerator;
+    };
+}): Promise<RunnerResult<ResponseTypes, ScoreTypes>>;
+
+type index$2_PeerbenchJSONDataLoader = PeerbenchJSONDataLoader;
+declare const index$2_PeerbenchJSONDataLoader: typeof PeerbenchJSONDataLoader;
+declare const index$2_PeerbenchMultipleChoiceResponseSchemaV1: typeof PeerbenchMultipleChoiceResponseSchemaV1;
+type index$2_PeerbenchMultipleChoiceResponseV1 = PeerbenchMultipleChoiceResponseV1;
+declare const index$2_PeerbenchMultipleChoiceScoreSchemaV1: typeof PeerbenchMultipleChoiceScoreSchemaV1;
+type index$2_PeerbenchMultipleChoiceScoreV1 = PeerbenchMultipleChoiceScoreV1;
+declare const index$2_PeerbenchMultipleChoiceTestCaseSchemaV1: typeof PeerbenchMultipleChoiceTestCaseSchemaV1;
+type index$2_PeerbenchMultipleChoiceTestCaseV1 = PeerbenchMultipleChoiceTestCaseV1;
+declare const index$2_PeerbenchOpenEndedResponseSchemaV1: typeof PeerbenchOpenEndedResponseSchemaV1;
+type index$2_PeerbenchOpenEndedResponseV1 = PeerbenchOpenEndedResponseV1;
+declare const index$2_PeerbenchOpenEndedScoreSchemaV1: typeof PeerbenchOpenEndedScoreSchemaV1;
+type index$2_PeerbenchOpenEndedScoreV1 = PeerbenchOpenEndedScoreV1;
+declare const index$2_PeerbenchOpenEndedTestCaseSchemaV1: typeof PeerbenchOpenEndedTestCaseSchemaV1;
+type index$2_PeerbenchOpenEndedTestCaseV1 = PeerbenchOpenEndedTestCaseV1;
+declare namespace index$2 {
+  export { index$2_PeerbenchJSONDataLoader as PeerbenchJSONDataLoader, index$2_PeerbenchMultipleChoiceResponseSchemaV1 as PeerbenchMultipleChoiceResponseSchemaV1, type index$2_PeerbenchMultipleChoiceResponseV1 as PeerbenchMultipleChoiceResponseV1, index$2_PeerbenchMultipleChoiceScoreSchemaV1 as PeerbenchMultipleChoiceScoreSchemaV1, type index$2_PeerbenchMultipleChoiceScoreV1 as PeerbenchMultipleChoiceScoreV1, index$2_PeerbenchMultipleChoiceTestCaseSchemaV1 as PeerbenchMultipleChoiceTestCaseSchemaV1, type index$2_PeerbenchMultipleChoiceTestCaseV1 as PeerbenchMultipleChoiceTestCaseV1, index$2_PeerbenchOpenEndedResponseSchemaV1 as PeerbenchOpenEndedResponseSchemaV1, type index$2_PeerbenchOpenEndedResponseV1 as PeerbenchOpenEndedResponseV1, index$2_PeerbenchOpenEndedScoreSchemaV1 as PeerbenchOpenEndedScoreSchemaV1, type index$2_PeerbenchOpenEndedScoreV1 as PeerbenchOpenEndedScoreV1, index$2_PeerbenchOpenEndedTestCaseSchemaV1 as PeerbenchOpenEndedTestCaseSchemaV1, type index$2_PeerbenchOpenEndedTestCaseV1 as PeerbenchOpenEndedTestCaseV1, runTestCase$2 as runTestCase };
+}
+
+declare const MMLUProMainTestCaseSchemaV1: z$1.ZodObject<Omit<{
+    id: z$1.ZodString;
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+    metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+}, "kind" | "schemaVersion"> & {
+    question: z$1.ZodString;
+    options: z$1.ZodRecord<z$1.ZodString, z$1.ZodString>;
+    answer: z$1.ZodString;
+    answerKey: z$1.ZodString;
+} & {
+    kind: z$1.ZodLiteral<"mmlu-pro.ts.main">;
+    schemaVersion: z$1.ZodLiteral<1>;
+}, z$1.core.$strip> & {
+    new: (input: Omit<{
+        id: string;
+        question: string;
+        options: Record<string, string>;
+        answer: string;
+        answerKey: string;
+        kind: "mmlu-pro.ts.main";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    }, "kind" | "schemaVersion">) => {
+        id: string;
+        question: string;
+        options: Record<string, string>;
+        answer: string;
+        answerKey: string;
+        kind: "mmlu-pro.ts.main";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    };
+    newWithId(input: Omit<{
+        id: string;
+        question: string;
+        options: Record<string, string>;
+        answer: string;
+        answerKey: string;
+        kind: "mmlu-pro.ts.main";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+        id: string;
+        question: string;
+        options: Record<string, string>;
+        answer: string;
+        answerKey: string;
+        kind: "mmlu-pro.ts.main";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    }>;
+};
+type MMLUProMainTestCaseV1 = z$1.infer<typeof MMLUProMainTestCaseSchemaV1>;
+declare const MMLUProMainResponseSchemaV1: z$1.ZodObject<Omit<Omit<{
+    id: z$1.ZodString;
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+    startedAt: z$1.ZodNumber;
+    completedAt: z$1.ZodNumber;
+    testCaseId: z$1.ZodString;
+    metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+}, "kind" | "schemaVersion"> & {
+    data: z$1.ZodString;
+    modelSlug: z$1.ZodString;
+    provider: z$1.ZodString;
+    systemPromptId: z$1.ZodOptional<z$1.ZodString>;
+    inputTokensUsed: z$1.ZodOptional<z$1.ZodNumber>;
+    outputTokensUsed: z$1.ZodOptional<z$1.ZodNumber>;
+    inputCost: z$1.ZodOptional<z$1.ZodString>;
+    outputCost: z$1.ZodOptional<z$1.ZodString>;
+} & {
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+}, "kind" | "schemaVersion"> & {
+    kind: z$1.ZodLiteral<"mmlu-pro.rs.main">;
+    schemaVersion: z$1.ZodLiteral<1>;
+}, z$1.core.$strip> & {
+    new: (input: Omit<{
+        id: string;
+        testCaseId: string;
+        startedAt: number;
+        completedAt: number;
+        data: string;
+        provider: string;
+        modelSlug: string;
+        kind: "mmlu-pro.rs.main";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+        systemPromptId?: string | undefined;
+    }, "kind" | "schemaVersion">) => {
+        id: string;
+        testCaseId: string;
+        startedAt: number;
+        completedAt: number;
+        data: string;
+        provider: string;
+        modelSlug: string;
+        kind: "mmlu-pro.rs.main";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+        systemPromptId?: string | undefined;
+    };
+    newWithId(input: Omit<{
+        id: string;
+        testCaseId: string;
+        startedAt: number;
+        completedAt: number;
+        data: string;
+        provider: string;
+        modelSlug: string;
+        kind: "mmlu-pro.rs.main";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+        systemPromptId?: string | undefined;
+    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+        id: string;
+        testCaseId: string;
+        startedAt: number;
+        completedAt: number;
+        data: string;
+        provider: string;
+        modelSlug: string;
+        kind: "mmlu-pro.rs.main";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+        systemPromptId?: string | undefined;
+    }>;
+};
+type MMLUProMainResponseV1 = z$1.infer<typeof MMLUProMainResponseSchemaV1>;
+declare const MMLUProMainScoreSchemaV1: z$1.ZodObject<Omit<Omit<{
+    id: z$1.ZodString;
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+    value: z$1.ZodNumber;
+    responseId: z$1.ZodString;
+    explanation: z$1.ZodOptional<z$1.ZodString>;
+    metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+    scoringMethod: z$1.ZodEnum<{
+        readonly ai: "ai";
+        readonly human: "human";
+        readonly algo: "algo";
+    }>;
+}, "kind" | "schemaVersion"> & {
+    scorerAIProvider: z$1.ZodOptional<z$1.ZodString>;
+    scorerAIModelSlug: z$1.ZodOptional<z$1.ZodString>;
+    scorerAIInputTokensUsed: z$1.ZodOptional<z$1.ZodNumber>;
+    scorerAIOutputTokensUsed: z$1.ZodOptional<z$1.ZodNumber>;
+    scorerAIInputCost: z$1.ZodOptional<z$1.ZodString>;
+    scorerAIOutputCost: z$1.ZodOptional<z$1.ZodString>;
+} & {
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+}, "kind" | "schemaVersion"> & {
+    extractedAnswers: z$1.ZodArray<z$1.ZodString>;
+} & {
+    kind: z$1.ZodLiteral<"mmlu-pro.sc.main">;
+    schemaVersion: z$1.ZodLiteral<1>;
+}, z$1.core.$strip> & {
+    new: (input: Omit<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        extractedAnswers: string[];
+        kind: "mmlu-pro.sc.main";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    }, "kind" | "schemaVersion">) => {
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        extractedAnswers: string[];
+        kind: "mmlu-pro.sc.main";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    };
+    newWithId(input: Omit<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        extractedAnswers: string[];
+        kind: "mmlu-pro.sc.main";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        extractedAnswers: string[];
+        kind: "mmlu-pro.sc.main";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    }>;
+};
+type MMLUProMainScoreV1 = z$1.infer<typeof MMLUProMainScoreSchemaV1>;
+
+declare const MMLUProBenchmarkSpecSchemaV1: z__default.ZodObject<Omit<{
+    kind: z__default.ZodString;
+    schemaVersion: z__default.ZodNumber;
+    metadata: z__default.ZodOptional<z__default.ZodRecord<z__default.ZodString, z__default.ZodUnknown>>;
+}, "kind" | "schemaVersion"> & {
+    kind: z__default.ZodLiteral<"mmlu-pro.benchmark.spec">;
+    schemaVersion: z__default.ZodLiteral<1>;
+}, z__default.core.$strip> & {
+    new: (input: Omit<{
+        kind: "mmlu-pro.benchmark.spec";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    }, "kind" | "schemaVersion">) => {
+        kind: "mmlu-pro.benchmark.spec";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    };
+    newWithId(input: Omit<{
+        kind: "mmlu-pro.benchmark.spec";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+        kind: "mmlu-pro.benchmark.spec";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    }>;
+};
+type MMLUProBenchmarkSpecV1 = z__default.infer<typeof MMLUProBenchmarkSpecSchemaV1>;
+
+declare class MMLUProJSONDataLoader extends AbstractDataLoader {
+    readonly kind = "mmlu-pro.load.json.data";
+    loadData(params: {
+        content: Uint8Array;
+    }): LoaderResult<MMLUProMainTestCaseV1, MMLUProMainResponseV1, MMLUProMainScoreV1>;
+    loadBenchmarkSpec(params: {
+        content: Uint8Array;
+    }): Promise<MMLUProBenchmarkSpecV1>;
+}
+declare class MMLUProParquetDataLoader extends AbstractDataLoader {
+    readonly kind = "mmlu-pro.load.parquet.data";
+    loadData(params: {
+        content: Uint8Array;
+    }): Promise<LoaderResult<MMLUProMainTestCaseV1, MMLUProMainResponseV1, MMLUProMainScoreV1>>;
+    loadBenchmarkSpec(params: {
+        content: Uint8Array;
+    }): Promise<MMLUProBenchmarkSpecV1>;
+}
+
+declare function runTestCase$1(params: {
+    testCase: MMLUProMainTestCaseV1;
+    provider: AbstractLLMProvider;
+    scorer?: MCQScorer | LLMJudgeScorer;
+    spec?: MMLUProBenchmarkSpecV1;
+    runConfig: {
+        model: string;
+        llmJudgeModel?: string;
+    };
+    systemPrompt?: SimpleSystemPromptV1;
+    idGenerators?: {
+        response?: IdGenerator;
+        score?: IdGenerator;
+    };
+}): Promise<RunnerResult<MMLUProMainResponseV1, MMLUProMainScoreV1>>;
+
+declare const BaseMMLUProScoreSchemaV1: z.ZodObject<Omit<{
+    id: z.ZodString;
+    kind: z.ZodString;
+    schemaVersion: z.ZodNumber;
+    value: z.ZodNumber;
+    responseId: z.ZodString;
+    explanation: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    scoringMethod: z.ZodEnum<{
+        readonly ai: "ai";
+        readonly human: "human";
+        readonly algo: "algo";
+    }>;
+}, "kind" | "schemaVersion"> & {
+    scorerAIProvider: z.ZodOptional<z.ZodString>;
+    scorerAIModelSlug: z.ZodOptional<z.ZodString>;
+    scorerAIInputTokensUsed: z.ZodOptional<z.ZodNumber>;
+    scorerAIOutputTokensUsed: z.ZodOptional<z.ZodNumber>;
+    scorerAIInputCost: z.ZodOptional<z.ZodString>;
+    scorerAIOutputCost: z.ZodOptional<z.ZodString>;
+} & {
+    kind: z.ZodString;
+    schemaVersion: z.ZodNumber;
+}, zod_v4_core.$strip> & {
+    new: (input: Omit<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        kind: string;
+        schemaVersion: number;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    }, "kind" | "schemaVersion">) => {
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        kind: string;
+        schemaVersion: number;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    };
+    newWithId(input: Omit<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        kind: string;
+        schemaVersion: number;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        kind: string;
+        schemaVersion: number;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    }>;
+};
+
+declare const index$1_BaseMMLUProScoreSchemaV1: typeof BaseMMLUProScoreSchemaV1;
+declare const index$1_MMLUProBenchmarkSpecSchemaV1: typeof MMLUProBenchmarkSpecSchemaV1;
+type index$1_MMLUProBenchmarkSpecV1 = MMLUProBenchmarkSpecV1;
+type index$1_MMLUProJSONDataLoader = MMLUProJSONDataLoader;
+declare const index$1_MMLUProJSONDataLoader: typeof MMLUProJSONDataLoader;
+declare const index$1_MMLUProMainResponseSchemaV1: typeof MMLUProMainResponseSchemaV1;
+type index$1_MMLUProMainResponseV1 = MMLUProMainResponseV1;
+declare const index$1_MMLUProMainScoreSchemaV1: typeof MMLUProMainScoreSchemaV1;
+type index$1_MMLUProMainScoreV1 = MMLUProMainScoreV1;
+declare const index$1_MMLUProMainTestCaseSchemaV1: typeof MMLUProMainTestCaseSchemaV1;
+type index$1_MMLUProMainTestCaseV1 = MMLUProMainTestCaseV1;
+type index$1_MMLUProParquetDataLoader = MMLUProParquetDataLoader;
+declare const index$1_MMLUProParquetDataLoader: typeof MMLUProParquetDataLoader;
+declare namespace index$1 {
+  export { index$1_BaseMMLUProScoreSchemaV1 as BaseMMLUProScoreSchemaV1, index$1_MMLUProBenchmarkSpecSchemaV1 as MMLUProBenchmarkSpecSchemaV1, type index$1_MMLUProBenchmarkSpecV1 as MMLUProBenchmarkSpecV1, index$1_MMLUProJSONDataLoader as MMLUProJSONDataLoader, index$1_MMLUProMainResponseSchemaV1 as MMLUProMainResponseSchemaV1, type index$1_MMLUProMainResponseV1 as MMLUProMainResponseV1, index$1_MMLUProMainScoreSchemaV1 as MMLUProMainScoreSchemaV1, type index$1_MMLUProMainScoreV1 as MMLUProMainScoreV1, index$1_MMLUProMainTestCaseSchemaV1 as MMLUProMainTestCaseSchemaV1, type index$1_MMLUProMainTestCaseV1 as MMLUProMainTestCaseV1, index$1_MMLUProParquetDataLoader as MMLUProParquetDataLoader, runTestCase$1 as runTestCase };
+}
+
+declare class FNOLFieldsScorer extends AbstractScorer {
+    readonly kind = "fnol.fields";
+    score(params: {
+        fieldsToCollect: Record<string, {
+            required?: boolean;
+            expected?: unknown;
+            description?: string;
+        }>;
+        extracted?: Record<string, unknown>;
+    }): Promise<BaseScorerResult & {
+        requiredKeys: string[];
+        presentKeys: string[];
+        missingKeys: string[];
+        mismatchedKeys: string[];
+    }>;
+}
+
+declare const FNOLFieldSchemaV1: z$1.ZodObject<{
+    description: z$1.ZodString;
+    required: z$1.ZodOptional<z$1.ZodBoolean>;
+    expected: z$1.ZodOptional<z$1.ZodUnknown>;
+    valueType: z$1.ZodOptional<z$1.ZodEnum<{
+        readonly string: "string";
+        readonly number: "number";
+        readonly boolean: "boolean";
+        readonly object: "object";
+    }>>;
+}, z$1.core.$strip>;
+declare const FNOLTestCaseSchemaV1: z$1.ZodObject<Omit<{
+    id: z$1.ZodString;
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+    metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+}, "kind" | "schemaVersion"> & {
+    /**
+     * Scenario starter message. This is what the "user" would say initially.
+     */
+    initialUserMessage: z$1.ZodString;
+    /**
+     * Private/structured information about the user and the incident.
+     * This is used by the user simulator LLM to answer the target model questions.
+     */
+    userProfile: z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>;
+    /**
+     * The fields the target model must collect.
+     * Keys are canonical identifiers (e.g. "policyNumber", "dateOfLoss").
+     */
+    fieldsToCollect: z$1.ZodRecord<z$1.ZodString, z$1.ZodObject<{
+        description: z$1.ZodString;
+        required: z$1.ZodOptional<z$1.ZodBoolean>;
+        expected: z$1.ZodOptional<z$1.ZodUnknown>;
+        valueType: z$1.ZodOptional<z$1.ZodEnum<{
+            readonly string: "string";
+            readonly number: "number";
+            readonly boolean: "boolean";
+            readonly object: "object";
+        }>>;
+    }, z$1.core.$strip>>;
+    /**
+     * Maximum number of back-and-forth turns (target question + user answer).
+     */
+    maxTurns: z$1.ZodDefault<z$1.ZodNumber>;
+} & {
+    kind: z$1.ZodLiteral<"fnol.ts.v1">;
+    schemaVersion: z$1.ZodLiteral<1>;
+}, z$1.core.$strip> & {
+    new: (input: Omit<{
+        id: string;
+        initialUserMessage: string;
+        userProfile: Record<string, unknown>;
+        fieldsToCollect: Record<string, {
+            description: string;
+            required?: boolean | undefined;
+            expected?: unknown;
+            valueType?: "string" | "number" | "boolean" | "object" | undefined;
+        }>;
+        maxTurns: number;
+        kind: "fnol.ts.v1";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    }, "kind" | "schemaVersion">) => {
+        id: string;
+        initialUserMessage: string;
+        userProfile: Record<string, unknown>;
+        fieldsToCollect: Record<string, {
+            description: string;
+            required?: boolean | undefined;
+            expected?: unknown;
+            valueType?: "string" | "number" | "boolean" | "object" | undefined;
+        }>;
+        maxTurns: number;
+        kind: "fnol.ts.v1";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    };
+    newWithId(input: Omit<{
+        id: string;
+        initialUserMessage: string;
+        userProfile: Record<string, unknown>;
+        fieldsToCollect: Record<string, {
+            description: string;
+            required?: boolean | undefined;
+            expected?: unknown;
+            valueType?: "string" | "number" | "boolean" | "object" | undefined;
+        }>;
+        maxTurns: number;
+        kind: "fnol.ts.v1";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+        id: string;
+        initialUserMessage: string;
+        userProfile: Record<string, unknown>;
+        fieldsToCollect: Record<string, {
+            description: string;
+            required?: boolean | undefined;
+            expected?: unknown;
+            valueType?: "string" | "number" | "boolean" | "object" | undefined;
+        }>;
+        maxTurns: number;
+        kind: "fnol.ts.v1";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    }>;
+};
+type FNOLTestCaseV1 = z$1.infer<typeof FNOLTestCaseSchemaV1>;
+declare const FNOLConversationMessageSchemaV1: z$1.ZodObject<{
+    role: z$1.ZodEnum<{
+        system: "system";
+        user: "user";
+        assistant: "assistant";
+    }>;
+    content: z$1.ZodString;
+}, z$1.core.$strip>;
+declare const FNOLResponseSchemaV1: z$1.ZodObject<Omit<Omit<{
+    id: z$1.ZodString;
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+    startedAt: z$1.ZodNumber;
+    completedAt: z$1.ZodNumber;
+    testCaseId: z$1.ZodString;
+    metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+}, "kind" | "schemaVersion"> & {
+    data: z$1.ZodString;
+    modelSlug: z$1.ZodString;
+    provider: z$1.ZodString;
+    systemPromptId: z$1.ZodOptional<z$1.ZodString>;
+    inputTokensUsed: z$1.ZodOptional<z$1.ZodNumber>;
+    outputTokensUsed: z$1.ZodOptional<z$1.ZodNumber>;
+    inputCost: z$1.ZodOptional<z$1.ZodString>;
+    outputCost: z$1.ZodOptional<z$1.ZodString>;
+} & {
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+}, "kind" | "schemaVersion"> & {
+    /**
+     * Full conversation between the target model and simulated user.
+     */
+    conversation: z$1.ZodArray<z$1.ZodObject<{
+        role: z$1.ZodEnum<{
+            system: "system";
+            user: "user";
+            assistant: "assistant";
+        }>;
+        content: z$1.ZodString;
+    }, z$1.core.$strip>>;
+    turnsUsed: z$1.ZodNumber;
+    doneReason: z$1.ZodEnum<{
+        readonly modelProvidedJson: "modelProvidedJson";
+        readonly reachedMaxTurns: "reachedMaxTurns";
+        readonly forcedFinalJson: "forcedFinalJson";
+    }>;
+    /**
+     * Parsed JSON object from the target model's final answer, if available.
+     */
+    extracted: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+} & {
+    kind: z$1.ZodLiteral<"fnol.rs.v1">;
+    schemaVersion: z$1.ZodLiteral<1>;
+}, z$1.core.$strip> & {
+    new: (input: Omit<{
+        id: string;
+        testCaseId: string;
+        startedAt: number;
+        completedAt: number;
+        data: string;
+        provider: string;
+        modelSlug: string;
+        conversation: {
+            role: "system" | "user" | "assistant";
+            content: string;
+        }[];
+        turnsUsed: number;
+        doneReason: "modelProvidedJson" | "reachedMaxTurns" | "forcedFinalJson";
+        kind: "fnol.rs.v1";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+        systemPromptId?: string | undefined;
+        extracted?: Record<string, unknown> | undefined;
+    }, "kind" | "schemaVersion">) => {
+        id: string;
+        testCaseId: string;
+        startedAt: number;
+        completedAt: number;
+        data: string;
+        provider: string;
+        modelSlug: string;
+        conversation: {
+            role: "system" | "user" | "assistant";
+            content: string;
+        }[];
+        turnsUsed: number;
+        doneReason: "modelProvidedJson" | "reachedMaxTurns" | "forcedFinalJson";
+        kind: "fnol.rs.v1";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+        systemPromptId?: string | undefined;
+        extracted?: Record<string, unknown> | undefined;
+    };
+    newWithId(input: Omit<{
+        id: string;
+        testCaseId: string;
+        startedAt: number;
+        completedAt: number;
+        data: string;
+        provider: string;
+        modelSlug: string;
+        conversation: {
+            role: "system" | "user" | "assistant";
+            content: string;
+        }[];
+        turnsUsed: number;
+        doneReason: "modelProvidedJson" | "reachedMaxTurns" | "forcedFinalJson";
+        kind: "fnol.rs.v1";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+        systemPromptId?: string | undefined;
+        extracted?: Record<string, unknown> | undefined;
+    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+        id: string;
+        testCaseId: string;
+        startedAt: number;
+        completedAt: number;
+        data: string;
+        provider: string;
+        modelSlug: string;
+        conversation: {
+            role: "system" | "user" | "assistant";
+            content: string;
+        }[];
+        turnsUsed: number;
+        doneReason: "modelProvidedJson" | "reachedMaxTurns" | "forcedFinalJson";
+        kind: "fnol.rs.v1";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+        systemPromptId?: string | undefined;
+        extracted?: Record<string, unknown> | undefined;
+    }>;
+};
+type FNOLResponseV1 = z$1.infer<typeof FNOLResponseSchemaV1>;
+declare const FNOLFieldsScoreSchemaV1: z$1.ZodObject<Omit<Omit<{
+    id: z$1.ZodString;
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+    value: z$1.ZodNumber;
+    responseId: z$1.ZodString;
+    explanation: z$1.ZodOptional<z$1.ZodString>;
+    metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+    scoringMethod: z$1.ZodEnum<{
+        readonly ai: "ai";
+        readonly human: "human";
+        readonly algo: "algo";
+    }>;
+}, "kind" | "schemaVersion"> & {
+    scorerAIProvider: z$1.ZodOptional<z$1.ZodString>;
+    scorerAIModelSlug: z$1.ZodOptional<z$1.ZodString>;
+    scorerAIInputTokensUsed: z$1.ZodOptional<z$1.ZodNumber>;
+    scorerAIOutputTokensUsed: z$1.ZodOptional<z$1.ZodNumber>;
+    scorerAIInputCost: z$1.ZodOptional<z$1.ZodString>;
+    scorerAIOutputCost: z$1.ZodOptional<z$1.ZodString>;
+} & {
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+}, "kind" | "schemaVersion"> & {
+    requiredKeys: z$1.ZodArray<z$1.ZodString>;
+    presentKeys: z$1.ZodArray<z$1.ZodString>;
+    missingKeys: z$1.ZodArray<z$1.ZodString>;
+    mismatchedKeys: z$1.ZodArray<z$1.ZodString>;
+} & {
+    kind: z$1.ZodLiteral<"fnol.sc.fields.v1">;
+    schemaVersion: z$1.ZodLiteral<1>;
+}, z$1.core.$strip> & {
+    new: (input: Omit<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        requiredKeys: string[];
+        presentKeys: string[];
+        missingKeys: string[];
+        mismatchedKeys: string[];
+        kind: "fnol.sc.fields.v1";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    }, "kind" | "schemaVersion">) => {
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        requiredKeys: string[];
+        presentKeys: string[];
+        missingKeys: string[];
+        mismatchedKeys: string[];
+        kind: "fnol.sc.fields.v1";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    };
+    newWithId(input: Omit<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        requiredKeys: string[];
+        presentKeys: string[];
+        missingKeys: string[];
+        mismatchedKeys: string[];
+        kind: "fnol.sc.fields.v1";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        requiredKeys: string[];
+        presentKeys: string[];
+        missingKeys: string[];
+        mismatchedKeys: string[];
+        kind: "fnol.sc.fields.v1";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    }>;
+};
+type FNOLFieldsScoreV1 = z$1.infer<typeof FNOLFieldsScoreSchemaV1>;
+declare const FNOLLLMJudgeScoreSchemaV1: z$1.ZodObject<Omit<Omit<{
+    id: z$1.ZodString;
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+    value: z$1.ZodNumber;
+    responseId: z$1.ZodString;
+    explanation: z$1.ZodOptional<z$1.ZodString>;
+    metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+    scoringMethod: z$1.ZodEnum<{
+        readonly ai: "ai";
+        readonly human: "human";
+        readonly algo: "algo";
+    }>;
+}, "kind" | "schemaVersion"> & {
+    scorerAIProvider: z$1.ZodOptional<z$1.ZodString>;
+    scorerAIModelSlug: z$1.ZodOptional<z$1.ZodString>;
+    scorerAIInputTokensUsed: z$1.ZodOptional<z$1.ZodNumber>;
+    scorerAIOutputTokensUsed: z$1.ZodOptional<z$1.ZodNumber>;
+    scorerAIInputCost: z$1.ZodOptional<z$1.ZodString>;
+    scorerAIOutputCost: z$1.ZodOptional<z$1.ZodString>;
+} & {
+    kind: z$1.ZodString;
+    schemaVersion: z$1.ZodNumber;
+}, "kind" | "schemaVersion"> & {
+    verdict: z$1.ZodOptional<z$1.ZodEnum<{
+        pass: "pass";
+        borderline: "borderline";
+        fail: "fail";
+    }>>;
+} & {
+    kind: z$1.ZodLiteral<"fnol.sc.llm-judge.v1">;
+    schemaVersion: z$1.ZodLiteral<1>;
+}, z$1.core.$strip> & {
+    new: (input: Omit<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        kind: "fnol.sc.llm-judge.v1";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+        verdict?: "pass" | "borderline" | "fail" | undefined;
+    }, "kind" | "schemaVersion">) => {
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        kind: "fnol.sc.llm-judge.v1";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+        verdict?: "pass" | "borderline" | "fail" | undefined;
+    };
+    newWithId(input: Omit<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        kind: "fnol.sc.llm-judge.v1";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+        verdict?: "pass" | "borderline" | "fail" | undefined;
+    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        kind: "fnol.sc.llm-judge.v1";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+        verdict?: "pass" | "borderline" | "fail" | undefined;
+    }>;
+};
+type FNOLLLMJudgeScoreV1 = z$1.infer<typeof FNOLLLMJudgeScoreSchemaV1>;
+
+declare function runTestCase(params: {
+    testCase: FNOLTestCaseV1;
+    provider: AbstractLLMProvider;
+    userSimulatorProvider?: AbstractLLMProvider;
+    scorer?: FNOLFieldsScorer | LLMJudgeScorer;
+    runConfig: {
+        model: string;
+        userSimulatorModel?: string;
+        llmJudgeModel?: string;
+        temperature?: number;
+        userSimulatorTemperature?: number;
+    };
+    systemPrompt?: SimpleSystemPromptV1;
+    idGenerators?: {
+        response?: IdGenerator;
+        score?: IdGenerator;
+    };
+}): Promise<RunnerResult<FNOLResponseV1, FNOLFieldsScoreV1 | FNOLLLMJudgeScoreV1>>;
+
+declare const FNOLBaseScoreSchemaV1: z.ZodObject<Omit<{
+    id: z.ZodString;
+    kind: z.ZodString;
+    schemaVersion: z.ZodNumber;
+    value: z.ZodNumber;
+    responseId: z.ZodString;
+    explanation: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    scoringMethod: z.ZodEnum<{
+        readonly ai: "ai";
+        readonly human: "human";
+        readonly algo: "algo";
+    }>;
+}, "kind" | "schemaVersion"> & {
+    scorerAIProvider: z.ZodOptional<z.ZodString>;
+    scorerAIModelSlug: z.ZodOptional<z.ZodString>;
+    scorerAIInputTokensUsed: z.ZodOptional<z.ZodNumber>;
+    scorerAIOutputTokensUsed: z.ZodOptional<z.ZodNumber>;
+    scorerAIInputCost: z.ZodOptional<z.ZodString>;
+    scorerAIOutputCost: z.ZodOptional<z.ZodString>;
+} & {
+    kind: z.ZodString;
+    schemaVersion: z.ZodNumber;
+}, zod_v4_core.$strip> & {
+    new: (input: Omit<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        kind: string;
+        schemaVersion: number;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    }, "kind" | "schemaVersion">) => {
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        kind: string;
+        schemaVersion: number;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    };
+    newWithId(input: Omit<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        kind: string;
+        schemaVersion: number;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        kind: string;
+        schemaVersion: number;
+        metadata?: Record<string, unknown> | undefined;
+        explanation?: string | undefined;
+        scorerAIProvider?: string | undefined;
+        scorerAIModelSlug?: string | undefined;
+        scorerAIInputTokensUsed?: number | undefined;
+        scorerAIOutputTokensUsed?: number | undefined;
+        scorerAIInputCost?: string | undefined;
+        scorerAIOutputCost?: string | undefined;
+    }>;
+};
+
+declare const FNOLFieldValueType: {
+    readonly string: "string";
+    readonly number: "number";
+    readonly boolean: "boolean";
+    readonly object: "object";
+};
+type FNOLFieldValueType = (typeof FNOLFieldValueType)[keyof typeof FNOLFieldValueType];
+declare const FNOLDoneReason: {
+    readonly modelProvidedJson: "modelProvidedJson";
+    readonly reachedMaxTurns: "reachedMaxTurns";
+    readonly forcedFinalJson: "forcedFinalJson";
+};
+type FNOLDoneReason = (typeof FNOLDoneReason)[keyof typeof FNOLDoneReason];
+
+declare const index_FNOLBaseScoreSchemaV1: typeof FNOLBaseScoreSchemaV1;
+declare const index_FNOLConversationMessageSchemaV1: typeof FNOLConversationMessageSchemaV1;
+type index_FNOLDoneReason = FNOLDoneReason;
+declare const index_FNOLFieldSchemaV1: typeof FNOLFieldSchemaV1;
+type index_FNOLFieldValueType = FNOLFieldValueType;
+declare const index_FNOLFieldsScoreSchemaV1: typeof FNOLFieldsScoreSchemaV1;
+type index_FNOLFieldsScoreV1 = FNOLFieldsScoreV1;
+type index_FNOLFieldsScorer = FNOLFieldsScorer;
+declare const index_FNOLFieldsScorer: typeof FNOLFieldsScorer;
+declare const index_FNOLLLMJudgeScoreSchemaV1: typeof FNOLLLMJudgeScoreSchemaV1;
+type index_FNOLLLMJudgeScoreV1 = FNOLLLMJudgeScoreV1;
+declare const index_FNOLResponseSchemaV1: typeof FNOLResponseSchemaV1;
+type index_FNOLResponseV1 = FNOLResponseV1;
+declare const index_FNOLTestCaseSchemaV1: typeof FNOLTestCaseSchemaV1;
+type index_FNOLTestCaseV1 = FNOLTestCaseV1;
+declare const index_runTestCase: typeof runTestCase;
+declare namespace index {
+  export { index_FNOLBaseScoreSchemaV1 as FNOLBaseScoreSchemaV1, index_FNOLConversationMessageSchemaV1 as FNOLConversationMessageSchemaV1, type index_FNOLDoneReason as FNOLDoneReason, index_FNOLFieldSchemaV1 as FNOLFieldSchemaV1, type index_FNOLFieldValueType as FNOLFieldValueType, index_FNOLFieldsScoreSchemaV1 as FNOLFieldsScoreSchemaV1, type index_FNOLFieldsScoreV1 as FNOLFieldsScoreV1, index_FNOLFieldsScorer as FNOLFieldsScorer, index_FNOLLLMJudgeScoreSchemaV1 as FNOLLLMJudgeScoreSchemaV1, type index_FNOLLLMJudgeScoreV1 as FNOLLLMJudgeScoreV1, index_FNOLResponseSchemaV1 as FNOLResponseSchemaV1, type index_FNOLResponseV1 as FNOLResponseV1, index_FNOLTestCaseSchemaV1 as FNOLTestCaseSchemaV1, type index_FNOLTestCaseV1 as FNOLTestCaseV1, index_runTestCase as runTestCase };
+}
+
+export { index as fnol, index$1 as mmluPro, index$2 as peerbench };