peerbench 0.0.7 → 0.0.9

package/dist/benchmarks/peerbench/schema-sets/mcq.v1.d.ts

@@ -0,0 +1,261 @@
+import { z } from "zod";
+export declare const MCQKind: "llm/mcq";
+export 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>;
+} & {
+    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>;
+        correctAnswerKeys: string[];
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.tc";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    }, "kind" | "namespace" | "schemaVersion">) => {
+        id: string;
+        question: string;
+        options: Record<string, string>;
+        correctAnswerKeys: string[];
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.tc";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    };
+    newWithId(input: Omit<{
+        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" | "id" | "namespace" | "schemaVersion">, generator: import("../../../index.js").IdGenerator): Promise<{
+        id: string;
+        question: string;
+        options: Record<string, string>;
+        correctAnswerKeys: string[];
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.tc";
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    }>;
+};
+export type MCQTestCaseV1 = z.infer<typeof MCQTestCaseSchemaV1>;
+export 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>;
+} & {
+    namespace: z.ZodLiteral<"peerbench.ai">;
+    kind: z.ZodLiteral<"llm/mcq.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/mcq.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;
+        modelSlug: string;
+        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;
+    };
+    newWithId(input: Omit<{
+        startedAt: number;
+        completedAt: number;
+        id: string;
+        testCaseId: string;
+        data: string;
+        modelSlug: string;
+        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;
+    }, "kind" | "id" | "namespace" | "schemaVersion">, generator: import("../../../index.js").IdGenerator): Promise<{
+        startedAt: number;
+        completedAt: number;
+        id: string;
+        testCaseId: string;
+        data: string;
+        modelSlug: string;
+        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;
+    }>;
+};
+export type MCQResponseV1 = z.infer<typeof MCQResponseSchemaV1>;
+export 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" | "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>;
+} & {
+    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[];
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.sc";
+        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;
+    }, "kind" | "namespace" | "schemaVersion">) => {
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        extractedAnswers: string[];
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.sc";
+        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: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        extractedAnswers: string[];
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.sc";
+        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;
+    }, "kind" | "id" | "namespace" | "schemaVersion">, generator: import("../../../index.js").IdGenerator): Promise<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        extractedAnswers: string[];
+        namespace: "peerbench.ai";
+        kind: "llm/mcq.sc";
+        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;
+    }>;
+};
+export type MCQScoreV1 = z.infer<typeof MCQScoreSchemaV1>;

package/dist/benchmarks/peerbench/schema-sets/multi-turn.v1.d.ts

@@ -0,0 +1,351 @@
+import { z } from "zod";
+export declare const MultiTurnKind: "llm/multi-turn";
+export 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>;
+} & {
+    namespace: z.ZodLiteral<"peerbench.ai">;
+    kind: z.ZodLiteral<"llm/multi-turn.tc">;
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strip> & {
+    new: (input: Omit<{
+        id: string;
+        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;
+        maxTurns?: number | undefined;
+        expectedOutcome?: string | undefined;
+    }, "kind" | "namespace" | "schemaVersion">) => {
+        id: string;
+        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;
+        maxTurns?: number | undefined;
+        expectedOutcome?: string | undefined;
+    };
+    newWithId(input: Omit<{
+        id: string;
+        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;
+        maxTurns?: number | undefined;
+        expectedOutcome?: string | undefined;
+    }, "kind" | "id" | "namespace" | "schemaVersion">, generator: import("../../../index.js").IdGenerator): Promise<{
+        id: string;
+        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;
+        maxTurns?: number | undefined;
+        expectedOutcome?: string | undefined;
+    }>;
+};
+export type MultiTurnTestCaseV1 = z.infer<typeof MultiTurnTestCaseSchemaV1>;
+export 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>;
+} & {
+    namespace: z.ZodLiteral<"peerbench.ai">;
+    kind: z.ZodLiteral<"llm/multi-turn.rs">;
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strip> & {
+    new: (input: Omit<{
+        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;
+        modelSlug: string;
+        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;
+    }, "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;
+        modelSlug: string;
+        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;
+    };
+    newWithId(input: Omit<{
+        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;
+        modelSlug: string;
+        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;
+    }, "kind" | "id" | "namespace" | "schemaVersion">, generator: import("../../../index.js").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;
+        modelSlug: string;
+        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;
+    }>;
+};
+export type MultiTurnResponseV1 = z.infer<typeof MultiTurnResponseSchemaV1>;
+export 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" | "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>;
+} & {
+    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";
+        individualScores: {
+            replyIndex: number;
+            value: number;
+        }[];
+        namespace: "peerbench.ai";
+        kind: "llm/multi-turn.sc";
+        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;
+    }, "kind" | "namespace" | "schemaVersion">) => {
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        individualScores: {
+            replyIndex: number;
+            value: number;
+        }[];
+        namespace: "peerbench.ai";
+        kind: "llm/multi-turn.sc";
+        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: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        individualScores: {
+            replyIndex: number;
+            value: number;
+        }[];
+        namespace: "peerbench.ai";
+        kind: "llm/multi-turn.sc";
+        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;
+    }, "kind" | "id" | "namespace" | "schemaVersion">, generator: import("../../../index.js").IdGenerator): Promise<{
+        id: string;
+        value: number;
+        responseId: string;
+        scoringMethod: "ai" | "human" | "algo";
+        individualScores: {
+            replyIndex: number;
+            value: number;
+        }[];
+        namespace: "peerbench.ai";
+        kind: "llm/multi-turn.sc";
+        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;
+    }>;
+};
+export type MultiTurnScoreV1 = z.infer<typeof MultiTurnScoreSchemaV1>;