peerbench 0.0.2-alpha.0 → 0.0.2-alpha.1

package/dist/benchmarks/index.d.ts

@@ -1,50 +1,47 @@
-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 { I as IdGenerator } from '../index-BAioQhp2.js';
+import { z } 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 { a as MCQScorer, L as LLMAsAJudgeScorer } from '../llm-judge-QThCZ9TQ.js';
+import { J as JSONFileStorage } from '../json-file-ZwzLUbje.js';
 import '../provider-BDjGp2y-.js';
+import '../abstract-Dec9Sc5O.js';
 import 'openai/resources/shared';
 import 'openai/resources/chat/completions';
 import '../rate-limiter-CSmVIRsM.js';
-import '../system-prompt--0FdPWqK.js';
+import 'node:fs/promises';
 
-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;
+declare const MCQKind: "llm/mcq";
+declare const MCQTestCaseSchemaV1: z.ZodObject<Omit<{
+    id: z.ZodString;
+    namespace: z.ZodString;
+    schemaVersion: z.ZodNumber;
+    kind: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "kind" | "namespace" | "schemaVersion"> & {
+    question: z.ZodString;
+    options: z.ZodRecord<z.ZodString, z.ZodString>;
+    correctAnswerKeys: z.ZodArray<z.ZodString>;
 } & {
-    kind: z$1.ZodLiteral<"pb.ts.mcq">;
-    schemaVersion: z$1.ZodLiteral<1>;
-}, z$1.core.$strip> & {
+    namespace: z.ZodLiteral<"peerbench.ai">;
+    kind: z.ZodLiteral<"llm/mcq.tc">;
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strip> & {
     new: (input: Omit<{
         id: string;
         question: string;
         options: Record<string, string>;
-        answer: string;
-        answerKey: string;
-        kind: "pb.ts.mcq";
+        correctAnswerKeys: string[];
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.tc";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
-    }, "kind" | "schemaVersion">) => {
+    }, "kind" | "namespace" | "schemaVersion">) => {
         id: string;
         question: string;
         options: Record<string, string>;
-        answer: string;
-        answerKey: string;
-        kind: "pb.ts.mcq";
+        correctAnswerKeys: string[];
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.tc";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
     };
@@ -52,170 +49,179 @@ declare const PeerbenchMultipleChoiceTestCaseSchemaV1: z$1.ZodObject<Omit<{
         id: string;
         question: string;
         options: Record<string, string>;
-        answer: string;
-        answerKey: string;
-        kind: "pb.ts.mcq";
+        correctAnswerKeys: string[];
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.tc";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
-    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+    }, "id" | "kind" | "namespace" | "schemaVersion">, generator: IdGenerator): Promise<{
         id: string;
         question: string;
         options: Record<string, string>;
-        answer: string;
-        answerKey: string;
-        kind: "pb.ts.mcq";
+        correctAnswerKeys: string[];
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.tc";
         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>;
+type MCQTestCaseV1 = z.infer<typeof MCQTestCaseSchemaV1>;
+declare const MCQResponseSchemaV1: z.ZodObject<Omit<{
+    id: z.ZodString;
+    namespace: z.ZodString;
+    schemaVersion: z.ZodNumber;
+    kind: z.ZodString;
+    startedAt: z.ZodNumber;
+    completedAt: z.ZodNumber;
+    testCaseId: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "kind" | "namespace" | "schemaVersion"> & {
+    data: z.ZodString;
+    modelSlug: z.ZodString;
+    provider: z.ZodString;
+    systemPromptId: z.ZodOptional<z.ZodString>;
+    inputTokensUsed: z.ZodOptional<z.ZodNumber>;
+    outputTokensUsed: z.ZodOptional<z.ZodNumber>;
+    inputCost: z.ZodOptional<z.ZodString>;
+    outputCost: z.ZodOptional<z.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> & {
+    namespace: z.ZodLiteral<"peerbench.ai">;
+    kind: z.ZodLiteral<"llm/mcq.rs">;
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strip> & {
     new: (input: Omit<{
-        id: string;
-        testCaseId: string;
         startedAt: number;
         completedAt: number;
+        id: string;
+        testCaseId: string;
         data: string;
-        provider: string;
         modelSlug: string;
-        kind: "pb.rs.mcq";
+        provider: string;
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.rs";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
+        systemPromptId?: string | undefined;
         inputTokensUsed?: number | undefined;
         outputTokensUsed?: number | undefined;
         inputCost?: string | undefined;
         outputCost?: string | undefined;
-        systemPromptId?: string | undefined;
-    }, "kind" | "schemaVersion">) => {
-        id: string;
-        testCaseId: string;
+    }, "kind" | "namespace" | "schemaVersion">) => {
         startedAt: number;
         completedAt: number;
+        id: string;
+        testCaseId: string;
         data: string;
-        provider: string;
         modelSlug: string;
-        kind: "pb.rs.mcq";
+        provider: string;
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.rs";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
+        systemPromptId?: string | 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;
+        id: string;
+        testCaseId: string;
         data: string;
-        provider: string;
         modelSlug: string;
-        kind: "pb.rs.mcq";
+        provider: string;
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.rs";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
+        systemPromptId?: string | 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;
+    }, "id" | "kind" | "namespace" | "schemaVersion">, generator: IdGenerator): Promise<{
         startedAt: number;
         completedAt: number;
+        id: string;
+        testCaseId: string;
         data: string;
-        provider: string;
         modelSlug: string;
-        kind: "pb.rs.mcq";
+        provider: string;
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.rs";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
+        systemPromptId?: string | 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<{
+type MCQResponseV1 = z.infer<typeof MCQResponseSchemaV1>;
+declare const MCQScoreSchemaV1: z.ZodObject<Omit<{
+    id: z.ZodString;
+    namespace: 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$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" | "namespace" | "schemaVersion"> & {
+    extractedAnswers: z.ZodArray<z.ZodString>;
+    scorerAISystemPrompt: z.ZodOptional<z.ZodString>;
+    scorerAISystemPromptId: z.ZodOptional<z.ZodString>;
+    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$1.ZodLiteral<"pb.sc.mcq">;
-    schemaVersion: z$1.ZodLiteral<1>;
-}, z$1.core.$strip> & {
+    namespace: z.ZodLiteral<"peerbench.ai">;
+    kind: z.ZodLiteral<"llm/mcq.sc">;
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strip> & {
     new: (input: Omit<{
         id: string;
         value: number;
         responseId: string;
         scoringMethod: "ai" | "human" | "algo";
         extractedAnswers: string[];
-        kind: "pb.sc.mcq";
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.sc";
         schemaVersion: 1;
-        metadata?: Record<string, unknown> | undefined;
         explanation?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        scorerAISystemPrompt?: string | undefined;
+        scorerAISystemPromptId?: string | undefined;
         scorerAIProvider?: string | undefined;
         scorerAIModelSlug?: string | undefined;
         scorerAIInputTokensUsed?: number | undefined;
         scorerAIOutputTokensUsed?: number | undefined;
         scorerAIInputCost?: string | undefined;
         scorerAIOutputCost?: string | undefined;
-    }, "kind" | "schemaVersion">) => {
+    }, "kind" | "namespace" | "schemaVersion">) => {
         id: string;
         value: number;
         responseId: string;
         scoringMethod: "ai" | "human" | "algo";
         extractedAnswers: string[];
-        kind: "pb.sc.mcq";
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.sc";
         schemaVersion: 1;
-        metadata?: Record<string, unknown> | undefined;
         explanation?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        scorerAISystemPrompt?: string | undefined;
+        scorerAISystemPromptId?: string | undefined;
         scorerAIProvider?: string | undefined;
         scorerAIModelSlug?: string | undefined;
         scorerAIInputTokensUsed?: number | undefined;
@@ -229,26 +235,32 @@ declare const PeerbenchMultipleChoiceScoreSchemaV1: z$1.ZodObject<Omit<Omit<{
         responseId: string;
         scoringMethod: "ai" | "human" | "algo";
         extractedAnswers: string[];
-        kind: "pb.sc.mcq";
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.sc";
         schemaVersion: 1;
-        metadata?: Record<string, unknown> | undefined;
         explanation?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        scorerAISystemPrompt?: string | undefined;
+        scorerAISystemPromptId?: 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" | "kind" | "namespace" | "schemaVersion">, generator: IdGenerator): Promise<{
         id: string;
         value: number;
         responseId: string;
         scoringMethod: "ai" | "human" | "algo";
         extractedAnswers: string[];
-        kind: "pb.sc.mcq";
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.sc";
         schemaVersion: 1;
-        metadata?: Record<string, unknown> | undefined;
         explanation?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        scorerAISystemPrompt?: string | undefined;
+        scorerAISystemPromptId?: string | undefined;
         scorerAIProvider?: string | undefined;
         scorerAIModelSlug?: string | undefined;
         scorerAIInputTokensUsed?: number | undefined;
@@ -257,195 +269,304 @@ declare const PeerbenchMultipleChoiceScoreSchemaV1: z$1.ZodObject<Omit<Omit<{
         scorerAIOutputCost?: string | undefined;
     }>;
 };
-type PeerbenchMultipleChoiceScoreV1 = z$1.infer<typeof PeerbenchMultipleChoiceScoreSchemaV1>;
+type MCQScoreV1 = z.infer<typeof MCQScoreSchemaV1>;
 
-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>;
+declare const MultiTurnKind: "llm/multi-turn";
+declare const MultiTurnTestCaseSchemaV1: z.ZodObject<Omit<{
+    id: z.ZodString;
+    namespace: z.ZodString;
+    schemaVersion: z.ZodNumber;
+    kind: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "kind" | "namespace" | "schemaVersion"> & {
+    messages: z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        content: z.ZodString;
+        goodAnswers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        badAnswers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    maxTurns: z.ZodOptional<z.ZodNumber>;
+    expectedOutcome: z.ZodOptional<z.ZodString>;
 } & {
-    kind: z$1.ZodLiteral<"pb.ts.open-ended">;
-    schemaVersion: z$1.ZodLiteral<1>;
-}, z$1.core.$strip> & {
+    namespace: z.ZodLiteral<"peerbench.ai">;
+    kind: z.ZodLiteral<"llm/multi-turn.tc">;
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strip> & {
     new: (input: Omit<{
         id: string;
-        question: string;
-        kind: "pb.ts.open-ended";
+        messages: {
+            role: string;
+            content: string;
+            goodAnswers?: string[] | undefined;
+            badAnswers?: string[] | undefined;
+        }[];
+        namespace: "peerbench.ai";
+        kind: "llm/multi-turn.tc";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
-        answer?: string | undefined;
-    }, "kind" | "schemaVersion">) => {
+        maxTurns?: number | undefined;
+        expectedOutcome?: string | undefined;
+    }, "kind" | "namespace" | "schemaVersion">) => {
         id: string;
-        question: string;
-        kind: "pb.ts.open-ended";
+        messages: {
+            role: string;
+            content: string;
+            goodAnswers?: string[] | undefined;
+            badAnswers?: string[] | undefined;
+        }[];
+        namespace: "peerbench.ai";
+        kind: "llm/multi-turn.tc";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
-        answer?: string | undefined;
+        maxTurns?: number | undefined;
+        expectedOutcome?: string | undefined;
     };
     newWithId(input: Omit<{
         id: string;
-        question: string;
-        kind: "pb.ts.open-ended";
+        messages: {
+            role: string;
+            content: string;
+            goodAnswers?: string[] | undefined;
+            badAnswers?: string[] | undefined;
+        }[];
+        namespace: "peerbench.ai";
+        kind: "llm/multi-turn.tc";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
-        answer?: string | undefined;
-    }, "id" | "kind" | "schemaVersion">, generator: IdGenerator): Promise<{
+        maxTurns?: number | undefined;
+        expectedOutcome?: string | undefined;
+    }, "id" | "kind" | "namespace" | "schemaVersion">, generator: IdGenerator): Promise<{
         id: string;
-        question: string;
-        kind: "pb.ts.open-ended";
+        messages: {
+            role: string;
+            content: string;
+            goodAnswers?: string[] | undefined;
+            badAnswers?: string[] | undefined;
+        }[];
+        namespace: "peerbench.ai";
+        kind: "llm/multi-turn.tc";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
-        answer?: string | undefined;
+        maxTurns?: number | undefined;
+        expectedOutcome?: 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>;
+type MultiTurnTestCaseV1 = z.infer<typeof MultiTurnTestCaseSchemaV1>;
+declare const MultiTurnResponseSchemaV1: z.ZodObject<Omit<{
+    id: z.ZodString;
+    namespace: z.ZodString;
+    schemaVersion: z.ZodNumber;
+    kind: z.ZodString;
+    startedAt: z.ZodNumber;
+    completedAt: z.ZodNumber;
+    testCaseId: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "kind" | "namespace" | "schemaVersion"> & {
+    replies: z.ZodArray<z.ZodObject<{
+        messageIndex: z.ZodNumber;
+        startedAt: z.ZodNumber;
+        completedAt: z.ZodNumber;
+        data: z.ZodString;
+        inputTokensUsed: z.ZodOptional<z.ZodNumber>;
+        outputTokensUsed: z.ZodOptional<z.ZodNumber>;
+        inputCost: z.ZodOptional<z.ZodString>;
+        outputCost: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    data: z.ZodString;
+    modelSlug: z.ZodString;
+    provider: z.ZodString;
+    systemPromptId: z.ZodOptional<z.ZodString>;
+    inputTokensUsed: z.ZodOptional<z.ZodNumber>;
+    outputTokensUsed: z.ZodOptional<z.ZodNumber>;
+    inputCost: z.ZodOptional<z.ZodString>;
+    outputCost: z.ZodOptional<z.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> & {
+    namespace: z.ZodLiteral<"peerbench.ai">;
+    kind: z.ZodLiteral<"llm/multi-turn.rs">;
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strip> & {
     new: (input: Omit<{
-        id: string;
-        testCaseId: string;
         startedAt: number;
         completedAt: number;
+        id: string;
+        testCaseId: string;
+        replies: {
+            messageIndex: number;
+            startedAt: number;
+            completedAt: number;
+            data: string;
+            inputTokensUsed?: number | undefined;
+            outputTokensUsed?: number | undefined;
+            inputCost?: string | undefined;
+            outputCost?: string | undefined;
+        }[];
         data: string;
-        provider: string;
         modelSlug: string;
-        kind: "pb.rs.open-ended";
+        provider: string;
+        namespace: "peerbench.ai";
+        kind: "llm/multi-turn.rs";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
+        systemPromptId?: string | undefined;
         inputTokensUsed?: number | undefined;
         outputTokensUsed?: number | undefined;
         inputCost?: string | undefined;
         outputCost?: string | undefined;
-        systemPromptId?: string | undefined;
-    }, "kind" | "schemaVersion">) => {
-        id: string;
-        testCaseId: string;
+    }, "kind" | "namespace" | "schemaVersion">) => {
         startedAt: number;
         completedAt: number;
+        id: string;
+        testCaseId: string;
+        replies: {
+            messageIndex: number;
+            startedAt: number;
+            completedAt: number;
+            data: string;
+            inputTokensUsed?: number | undefined;
+            outputTokensUsed?: number | undefined;
+            inputCost?: string | undefined;
+            outputCost?: string | undefined;
+        }[];
         data: string;
-        provider: string;
         modelSlug: string;
-        kind: "pb.rs.open-ended";
+        provider: string;
+        namespace: "peerbench.ai";
+        kind: "llm/multi-turn.rs";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
+        systemPromptId?: string | 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;
+        id: string;
+        testCaseId: string;
+        replies: {
+            messageIndex: number;
+            startedAt: number;
+            completedAt: number;
+            data: string;
+            inputTokensUsed?: number | undefined;
+            outputTokensUsed?: number | undefined;
+            inputCost?: string | undefined;
+            outputCost?: string | undefined;
+        }[];
         data: string;
-        provider: string;
         modelSlug: string;
-        kind: "pb.rs.open-ended";
+        provider: string;
+        namespace: "peerbench.ai";
+        kind: "llm/multi-turn.rs";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
+        systemPromptId?: string | 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;
+    }, "id" | "kind" | "namespace" | "schemaVersion">, generator: IdGenerator): Promise<{
         startedAt: number;
         completedAt: number;
+        id: string;
+        testCaseId: string;
+        replies: {
+            messageIndex: number;
+            startedAt: number;
+            completedAt: number;
+            data: string;
+            inputTokensUsed?: number | undefined;
+            outputTokensUsed?: number | undefined;
+            inputCost?: string | undefined;
+            outputCost?: string | undefined;
+        }[];
         data: string;
-        provider: string;
         modelSlug: string;
-        kind: "pb.rs.open-ended";
+        provider: string;
+        namespace: "peerbench.ai";
+        kind: "llm/multi-turn.rs";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
+        systemPromptId?: string | 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<{
+type MultiTurnResponseV1 = z.infer<typeof MultiTurnResponseSchemaV1>;
+declare const MultiTurnScoreSchemaV1: z.ZodObject<Omit<{
+    id: z.ZodString;
+    namespace: 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$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" | "namespace" | "schemaVersion"> & {
+    individualScores: z.ZodArray<z.ZodObject<{
+        replyIndex: z.ZodNumber;
+        value: z.ZodNumber;
+    }, z.core.$strip>>;
+    scorerAISystemPrompt: z.ZodOptional<z.ZodString>;
+    scorerAISystemPromptId: z.ZodOptional<z.ZodString>;
+    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$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> & {
+    namespace: z.ZodLiteral<"peerbench.ai">;
+    kind: z.ZodLiteral<"llm/multi-turn.sc">;
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strip> & {
     new: (input: Omit<{
         id: string;
         value: number;
         responseId: string;
         scoringMethod: "ai" | "human" | "algo";
-        kind: "pb.sc.open-ended";
+        individualScores: {
+            replyIndex: number;
+            value: number;
+        }[];
+        namespace: "peerbench.ai";
+        kind: "llm/multi-turn.sc";
         schemaVersion: 1;
-        metadata?: Record<string, unknown> | undefined;
         explanation?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        scorerAISystemPrompt?: string | undefined;
+        scorerAISystemPromptId?: string | undefined;
         scorerAIProvider?: string | undefined;
         scorerAIModelSlug?: string | undefined;
         scorerAIInputTokensUsed?: number | undefined;
         scorerAIOutputTokensUsed?: number | undefined;
         scorerAIInputCost?: string | undefined;
         scorerAIOutputCost?: string | undefined;
-    }, "kind" | "schemaVersion">) => {
+    }, "kind" | "namespace" | "schemaVersion">) => {
         id: string;
         value: number;
         responseId: string;
         scoringMethod: "ai" | "human" | "algo";
-        kind: "pb.sc.open-ended";
+        individualScores: {
+            replyIndex: number;
+            value: number;
+        }[];
+        namespace: "peerbench.ai";
+        kind: "llm/multi-turn.sc";
         schemaVersion: 1;
-        metadata?: Record<string, unknown> | undefined;
         explanation?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        scorerAISystemPrompt?: string | undefined;
+        scorerAISystemPromptId?: string | undefined;
         scorerAIProvider?: string | undefined;
         scorerAIModelSlug?: string | undefined;
         scorerAIInputTokensUsed?: number | undefined;
@@ -458,25 +579,39 @@ declare const PeerbenchOpenEndedScoreSchemaV1: z$1.ZodObject<Omit<Omit<{
         value: number;
         responseId: string;
         scoringMethod: "ai" | "human" | "algo";
-        kind: "pb.sc.open-ended";
+        individualScores: {
+            replyIndex: number;
+            value: number;
+        }[];
+        namespace: "peerbench.ai";
+        kind: "llm/multi-turn.sc";
         schemaVersion: 1;
-        metadata?: Record<string, unknown> | undefined;
         explanation?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        scorerAISystemPrompt?: string | undefined;
+        scorerAISystemPromptId?: 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" | "kind" | "namespace" | "schemaVersion">, generator: IdGenerator): Promise<{
         id: string;
         value: number;
         responseId: string;
         scoringMethod: "ai" | "human" | "algo";
-        kind: "pb.sc.open-ended";
+        individualScores: {
+            replyIndex: number;
+            value: number;
+        }[];
+        namespace: "peerbench.ai";
+        kind: "llm/multi-turn.sc";
         schemaVersion: 1;
-        metadata?: Record<string, unknown> | undefined;
         explanation?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        scorerAISystemPrompt?: string | undefined;
+        scorerAISystemPromptId?: string | undefined;
         scorerAIProvider?: string | undefined;
         scorerAIModelSlug?: string | undefined;
         scorerAIInputTokensUsed?: number | undefined;
@@ -485,406 +620,254 @@ declare const PeerbenchOpenEndedScoreSchemaV1: z$1.ZodObject<Omit<Omit<{
         scorerAIOutputCost?: string | undefined;
     }>;
 };
-type PeerbenchOpenEndedScoreV1 = z$1.infer<typeof PeerbenchOpenEndedScoreSchemaV1>;
+type MultiTurnScoreV1 = z.infer<typeof MultiTurnScoreSchemaV1>;
 
-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>>;
+declare const QAKind: "llm/qa";
+declare const QATestCaseSchemaV1: z.ZodObject<Omit<{
+    id: z.ZodString;
+    namespace: z.ZodString;
+    schemaVersion: z.ZodNumber;
+    kind: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "kind" | "namespace" | "schemaVersion"> & {
+    question: z.ZodString;
+    goodAnswers: z.ZodArray<z.ZodString>;
+    badAnswers: z.ZodArray<z.ZodString>;
 } & {
-    kind: z__default.ZodLiteral<"pb.benchmark.spec">;
-    schemaVersion: z__default.ZodLiteral<1>;
-}, z__default.core.$strip> & {
+    namespace: z.ZodLiteral<"peerbench.ai">;
+    kind: z.ZodLiteral<"llm/qa.tc">;
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strip> & {
     new: (input: Omit<{
-        kind: "pb.benchmark.spec";
+        id: string;
+        question: string;
+        goodAnswers: string[];
+        badAnswers: string[];
+        namespace: "peerbench.ai";
+        kind: "llm/qa.tc";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
-        blobTexts?: Record<string, string> | undefined;
-    }, "kind" | "schemaVersion">) => {
-        kind: "pb.benchmark.spec";
+    }, "kind" | "namespace" | "schemaVersion">) => {
+        id: string;
+        question: string;
+        goodAnswers: string[];
+        badAnswers: string[];
+        namespace: "peerbench.ai";
+        kind: "llm/qa.tc";
         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";
+        goodAnswers: string[];
+        badAnswers: string[];
+        namespace: "peerbench.ai";
+        kind: "llm/qa.tc";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
-    } | {
+    }, "id" | "kind" | "namespace" | "schemaVersion">, generator: IdGenerator): Promise<{
         id: string;
         question: string;
-        kind: "pb.ts.open-ended";
+        goodAnswers: string[];
+        badAnswers: string[];
+        namespace: "peerbench.ai";
+        kind: "llm/qa.tc";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
-        answer?: string | undefined;
-    } | undefined;
-    protected responseBuilder(data: any): Promise<{
+    }>;
+};
+type QATestCaseV1 = z.infer<typeof QATestCaseSchemaV1>;
+declare const QAResponseSchemaV1: z.ZodObject<Omit<{
+    id: z.ZodString;
+    namespace: z.ZodString;
+    schemaVersion: z.ZodNumber;
+    kind: z.ZodString;
+    startedAt: z.ZodNumber;
+    completedAt: z.ZodNumber;
+    testCaseId: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "kind" | "namespace" | "schemaVersion"> & {
+    data: z.ZodString;
+    modelSlug: z.ZodString;
+    provider: z.ZodString;
+    systemPromptId: z.ZodOptional<z.ZodString>;
+    inputTokensUsed: z.ZodOptional<z.ZodNumber>;
+    outputTokensUsed: z.ZodOptional<z.ZodNumber>;
+    inputCost: z.ZodOptional<z.ZodString>;
+    outputCost: z.ZodOptional<z.ZodString>;
+} & {
+    namespace: z.ZodLiteral<"peerbench.ai">;
+    kind: z.ZodLiteral<"llm/qa.rs">;
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strip> & {
+    new: (input: Omit<{
+        startedAt: number;
+        completedAt: number;
         id: string;
         testCaseId: string;
+        data: string;
+        modelSlug: string;
+        provider: string;
+        namespace: "peerbench.ai";
+        kind: "llm/qa.rs";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        systemPromptId?: string | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+    }, "kind" | "namespace" | "schemaVersion">) => {
         startedAt: number;
         completedAt: number;
+        id: string;
+        testCaseId: string;
         data: string;
-        provider: string;
         modelSlug: string;
-        kind: "pb.rs.mcq";
+        provider: string;
+        namespace: "peerbench.ai";
+        kind: "llm/qa.rs";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
+        systemPromptId?: string | undefined;
         inputTokensUsed?: number | undefined;
         outputTokensUsed?: number | undefined;
         inputCost?: string | undefined;
         outputCost?: string | undefined;
-        systemPromptId?: string | undefined;
-    } | {
+    };
+    newWithId(input: Omit<{
+        startedAt: number;
+        completedAt: number;
         id: string;
         testCaseId: string;
+        data: string;
+        modelSlug: string;
+        provider: string;
+        namespace: "peerbench.ai";
+        kind: "llm/qa.rs";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+        systemPromptId?: string | undefined;
+        inputTokensUsed?: number | undefined;
+        outputTokensUsed?: number | undefined;
+        inputCost?: string | undefined;
+        outputCost?: string | undefined;
+    }, "id" | "kind" | "namespace" | "schemaVersion">, generator: IdGenerator): Promise<{
         startedAt: number;
         completedAt: number;
+        id: string;
+        testCaseId: string;
         data: string;
-        provider: string;
         modelSlug: string;
-        kind: "pb.rs.open-ended";
+        provider: string;
+        namespace: "peerbench.ai";
+        kind: "llm/qa.rs";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
+        systemPromptId?: string | undefined;
         inputTokensUsed?: number | undefined;
         outputTokensUsed?: number | undefined;
         inputCost?: string | undefined;
         outputCost?: string | undefined;
-        systemPromptId?: string | undefined;
-    } | undefined>;
-    protected scoreBuilder(data: any): Promise<{
+    }>;
+};
+type QAResponseV1 = z.infer<typeof QAResponseSchemaV1>;
+declare const QAScoreSchemaV1: z.ZodObject<Omit<{
+    id: z.ZodString;
+    namespace: 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" | "namespace" | "schemaVersion"> & {
+    scorerAISystemPrompt: z.ZodOptional<z.ZodString>;
+    scorerAISystemPromptId: z.ZodOptional<z.ZodString>;
+    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>;
+} & {
+    namespace: z.ZodLiteral<"peerbench.ai">;
+    kind: z.ZodLiteral<"llm/qa.sc">;
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strip> & {
+    new: (input: Omit<{
         id: string;
         value: number;
         responseId: string;
         scoringMethod: "ai" | "human" | "algo";
-        extractedAnswers: string[];
-        kind: "pb.sc.mcq";
+        namespace: "peerbench.ai";
+        kind: "llm/qa.sc";
         schemaVersion: 1;
-        metadata?: Record<string, unknown> | undefined;
         explanation?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        scorerAISystemPrompt?: string | undefined;
+        scorerAISystemPromptId?: string | undefined;
         scorerAIProvider?: string | undefined;
         scorerAIModelSlug?: string | undefined;
         scorerAIInputTokensUsed?: number | undefined;
         scorerAIOutputTokensUsed?: number | undefined;
         scorerAIInputCost?: string | undefined;
         scorerAIOutputCost?: string | undefined;
-    } | {
+    }, "kind" | "namespace" | "schemaVersion">) => {
         id: string;
         value: number;
         responseId: string;
         scoringMethod: "ai" | "human" | "algo";
-        kind: "pb.sc.open-ended";
+        namespace: "peerbench.ai";
+        kind: "llm/qa.sc";
         schemaVersion: 1;
-        metadata?: Record<string, unknown> | undefined;
         explanation?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        scorerAISystemPrompt?: string | undefined;
+        scorerAISystemPromptId?: 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<{
+    newWithId(input: Omit<{
         id: string;
         value: number;
         responseId: string;
         scoringMethod: "ai" | "human" | "algo";
-        extractedAnswers: string[];
-        kind: "mmlu-pro.sc.main";
+        namespace: "peerbench.ai";
+        kind: "llm/qa.sc";
         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;
+        scorerAISystemPrompt?: string | undefined;
+        scorerAISystemPromptId?: string | undefined;
         scorerAIProvider?: string | undefined;
         scorerAIModelSlug?: string | undefined;
         scorerAIInputTokensUsed?: number | undefined;
         scorerAIOutputTokensUsed?: number | undefined;
         scorerAIInputCost?: string | undefined;
         scorerAIOutputCost?: string | undefined;
-    };
-    newWithId(input: Omit<{
+    }, "id" | "kind" | "namespace" | "schemaVersion">, generator: IdGenerator): Promise<{
         id: string;
         value: number;
         responseId: string;
         scoringMethod: "ai" | "human" | "algo";
-        extractedAnswers: string[];
-        kind: "mmlu-pro.sc.main";
+        namespace: "peerbench.ai";
+        kind: "llm/qa.sc";
         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;
+        scorerAISystemPrompt?: string | undefined;
+        scorerAISystemPromptId?: string | undefined;
         scorerAIProvider?: string | undefined;
         scorerAIModelSlug?: string | undefined;
         scorerAIInputTokensUsed?: number | undefined;
@@ -893,806 +876,166 @@ declare const MMLUProMainScoreSchemaV1: z$1.ZodObject<Omit<Omit<{
         scorerAIOutputCost?: string | undefined;
     }>;
 };
-type MMLUProMainScoreV1 = z$1.infer<typeof MMLUProMainScoreSchemaV1>;
+type QAScoreV1 = z.infer<typeof QAScoreSchemaV1>;
 
-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";
+declare const peerbenchRunner: (params: {
+    testCase: {
+        id: string;
+        question: string;
+        options: Record<string, string>;
+        correctAnswerKeys: string[];
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.tc";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
-    }, "kind" | "schemaVersion">) => {
-        kind: "mmlu-pro.benchmark.spec";
+    } | {
+        id: string;
+        question: string;
+        goodAnswers: string[];
+        badAnswers: string[];
+        namespace: "peerbench.ai";
+        kind: "llm/qa.tc";
         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;
+    scorer?: MCQScorer | LLMAsAJudgeScorer | undefined;
     runConfig: {
         model: string;
-        llmJudgeModel?: string;
+        llmJudgeModel?: string | undefined;
+        llmJudgeSystemPrompt?: {
+            id: string;
+            version: number;
+            content: string;
+            namespace: "peerbench.ai";
+            kind: `${string}/simple.sys-prompt`;
+            schemaVersion: 1;
+            metadata?: Record<string, unknown> | undefined;
+        } | undefined;
+        systemPrompt?: {
+            id: string;
+            version: number;
+            content: string;
+            namespace: "peerbench.ai";
+            kind: `${string}/simple.sys-prompt`;
+            schemaVersion: 1;
+            metadata?: Record<string, unknown> | undefined;
+        } | undefined;
+        templateVariables?: Record<string, string> | undefined;
     };
-    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;
+}) => Promise<{
+    response: {
         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";
+        provider: string;
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.rs";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
+        systemPromptId?: string | 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";
+        provider: string;
+        namespace: "peerbench.ai";
+        kind: "llm/qa.rs";
         schemaVersion: 1;
         metadata?: Record<string, unknown> | undefined;
+        systemPromptId?: string | 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<{
+    score?: {
         id: string;
         value: number;
         responseId: string;
         scoringMethod: "ai" | "human" | "algo";
-        kind: "fnol.sc.llm-judge.v1";
+        extractedAnswers: string[];
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.sc";
         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;
+        scorerAISystemPrompt?: string | undefined;
+        scorerAISystemPromptId?: 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";
+        namespace: "peerbench.ai";
+        kind: "llm/qa.sc";
         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;
+        scorerAISystemPrompt?: string | undefined;
+        scorerAISystemPromptId?: 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;
-    }>;
-};
+    } | 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 class PeerbenchJSONStorage extends JSONFileStorage<MCQTestCaseV1 | MCQResponseV1 | MCQScoreV1 | QATestCaseV1 | QAResponseV1 | QAScoreV1 | MultiTurnTestCaseV1 | MultiTurnResponseV1 | MultiTurnScoreV1> {
+    constructor(config: {
+        path: string;
+        chunkSize?: number;
+    });
+}
 
-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 const index_MCQKind: typeof MCQKind;
+declare const index_MCQResponseSchemaV1: typeof MCQResponseSchemaV1;
+type index_MCQResponseV1 = MCQResponseV1;
+declare const index_MCQScoreSchemaV1: typeof MCQScoreSchemaV1;
+type index_MCQScoreV1 = MCQScoreV1;
+declare const index_MCQTestCaseSchemaV1: typeof MCQTestCaseSchemaV1;
+type index_MCQTestCaseV1 = MCQTestCaseV1;
+declare const index_MultiTurnKind: typeof MultiTurnKind;
+declare const index_MultiTurnResponseSchemaV1: typeof MultiTurnResponseSchemaV1;
+type index_MultiTurnResponseV1 = MultiTurnResponseV1;
+declare const index_MultiTurnScoreSchemaV1: typeof MultiTurnScoreSchemaV1;
+type index_MultiTurnScoreV1 = MultiTurnScoreV1;
+declare const index_MultiTurnTestCaseSchemaV1: typeof MultiTurnTestCaseSchemaV1;
+type index_MultiTurnTestCaseV1 = MultiTurnTestCaseV1;
+type index_PeerbenchJSONStorage = PeerbenchJSONStorage;
+declare const index_PeerbenchJSONStorage: typeof PeerbenchJSONStorage;
+declare const index_QAKind: typeof QAKind;
+declare const index_QAResponseSchemaV1: typeof QAResponseSchemaV1;
+type index_QAResponseV1 = QAResponseV1;
+declare const index_QAScoreSchemaV1: typeof QAScoreSchemaV1;
+type index_QAScoreV1 = QAScoreV1;
+declare const index_QATestCaseSchemaV1: typeof QATestCaseSchemaV1;
+type index_QATestCaseV1 = QATestCaseV1;
+declare const index_peerbenchRunner: typeof peerbenchRunner;
 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_MCQKind as MCQKind, index_MCQResponseSchemaV1 as MCQResponseSchemaV1, type index_MCQResponseV1 as MCQResponseV1, index_MCQScoreSchemaV1 as MCQScoreSchemaV1, type index_MCQScoreV1 as MCQScoreV1, index_MCQTestCaseSchemaV1 as MCQTestCaseSchemaV1, type index_MCQTestCaseV1 as MCQTestCaseV1, index_MultiTurnKind as MultiTurnKind, index_MultiTurnResponseSchemaV1 as MultiTurnResponseSchemaV1, type index_MultiTurnResponseV1 as MultiTurnResponseV1, index_MultiTurnScoreSchemaV1 as MultiTurnScoreSchemaV1, type index_MultiTurnScoreV1 as MultiTurnScoreV1, index_MultiTurnTestCaseSchemaV1 as MultiTurnTestCaseSchemaV1, type index_MultiTurnTestCaseV1 as MultiTurnTestCaseV1, index_PeerbenchJSONStorage as PeerbenchJSONStorage, index_QAKind as QAKind, index_QAResponseSchemaV1 as QAResponseSchemaV1, type index_QAResponseV1 as QAResponseV1, index_QAScoreSchemaV1 as QAScoreSchemaV1, type index_QAScoreV1 as QAScoreV1, index_QATestCaseSchemaV1 as QATestCaseSchemaV1, type index_QATestCaseV1 as QATestCaseV1, index_peerbenchRunner as peerbenchRunner };
 }
 
-export { index as fnol, index$1 as mmluPro, index$2 as peerbench };
+export { index as peerbench };