peerbench 0.0.7 → 0.0.8

package/dist/schemas/llm/simple-system-prompt.d.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+export declare const SimpleSystemPromptSchemaV1: z.ZodObject<Omit<{
+    id: z.ZodString;
+    namespace: z.ZodString;
+    kind: z.ZodString;
+    schemaVersion: z.ZodNumber;
+    version: z.ZodNumber;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "kind" | "namespace" | "schemaVersion"> & {
+    content: z.ZodString;
+} & {
+    namespace: z.ZodLiteral<"peerbench.ai">;
+    kind: z.ZodLiteral<`${string}/simple.sys-prompt`>;
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strip> & {
+    new: (input: Omit<{
+        id: string;
+        version: number;
+        content: string;
+        namespace: "peerbench.ai";
+        kind: `${string}/simple.sys-prompt`;
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    }, "kind" | "namespace" | "schemaVersion">) => {
+        id: string;
+        version: number;
+        content: string;
+        namespace: "peerbench.ai";
+        kind: `${string}/simple.sys-prompt`;
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    };
+    newWithId(input: Omit<{
+        id: string;
+        version: number;
+        content: string;
+        namespace: "peerbench.ai";
+        kind: `${string}/simple.sys-prompt`;
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    }, "kind" | "id" | "namespace" | "schemaVersion">, generator: import("../../index.js").IdGenerator): Promise<{
+        id: string;
+        version: number;
+        content: string;
+        namespace: "peerbench.ai";
+        kind: `${string}/simple.sys-prompt`;
+        schemaVersion: 1;
+        metadata?: Record<string, unknown> | undefined;
+    }>;
+};
+export type SimpleSystemPromptV1 = z.infer<typeof SimpleSystemPromptSchemaV1>;

package/dist/schemas/llm/system-prompt.d.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+export declare const BaseSystemPromptSchemaV1: z.ZodObject<{
+    id: z.ZodString;
+    namespace: z.ZodString;
+    kind: z.ZodString;
+    schemaVersion: z.ZodNumber;
+    version: z.ZodNumber;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type BaseSystemPromptV1 = z.infer<typeof BaseSystemPromptSchemaV1>;
+export declare const defineSystemPromptSchema: <TBaseSchema extends import("../../index.js").WidenZodObject<z.ZodObject<{
+    id: z.ZodString;
+    namespace: z.ZodString;
+    kind: z.ZodString;
+    schemaVersion: z.ZodNumber;
+    version: z.ZodNumber;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>>, TNamespace extends string | undefined = undefined, TKind extends string | undefined = undefined, TSchemaVersion extends number | undefined = undefined, TFields extends Readonly<{
+    [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}> = {}>(config: {
+    baseSchema: TBaseSchema;
+    namespace?: TNamespace | undefined;
+    kind?: TKind | undefined;
+    schemaVersion?: TSchemaVersion | undefined;
+    fields?: TFields | undefined;
+}) => (TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+    [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+    namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+    kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.sys-prompt`>;
+    schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+}, z.core.$strip> : never) & {
+    new: (input: Omit<z.core.output<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.sys-prompt`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>, "kind" | "namespace" | "schemaVersion">) => z.core.output<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.sys-prompt`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>;
+    newWithId(input: Omit<z.core.output<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.sys-prompt`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>, "kind" | "id" | "namespace" | "schemaVersion">, generator: import("../../index.js").IdGenerator): Promise<z.core.output<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.sys-prompt`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>>;
+};

package/dist/schemas/response.d.ts

@@ -0,0 +1,63 @@
+import z from "zod";
+export declare const BaseResponseSchemaV1: z.ZodObject<{
+    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>>;
+}, z.core.$strip>;
+export type BaseResponseV1 = z.infer<typeof BaseResponseSchemaV1>;
+export declare const defineResponseSchema: <TBaseSchema extends import("../index.js").WidenZodObject<z.ZodObject<{
+    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>>;
+}, z.core.$strip>>, TNamespace extends string | undefined = undefined, TKind extends string | undefined = undefined, TSchemaVersion extends number | undefined = undefined, TFields extends Readonly<{
+    [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}> = {}>(config: {
+    baseSchema: TBaseSchema;
+    namespace?: TNamespace | undefined;
+    kind?: TKind | undefined;
+    schemaVersion?: TSchemaVersion | undefined;
+    fields?: TFields | undefined;
+}) => (TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+    [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+    namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+    kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.rs`>;
+    schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+}, z.core.$strip> : never) & {
+    new: (input: Omit<z.core.output<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.rs`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>, "kind" | "namespace" | "schemaVersion">) => z.core.output<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.rs`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>;
+    newWithId(input: Omit<z.core.output<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.rs`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>, "kind" | "id" | "namespace" | "schemaVersion">, generator: import("../index.js").IdGenerator): Promise<z.core.output<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.rs`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>>;
+};

package/dist/schemas/schema-definer.d.ts

@@ -0,0 +1,47 @@
+import { IdGenerator } from "../types";
+import { WidenZodObject } from "../utilities";
+import z from "zod";
+export declare function buildSchemaDefiner<TBaseShape extends {
+    kind: z.ZodString | z.ZodLiteral<string>;
+    namespace: z.ZodString | z.ZodLiteral<string>;
+    schemaVersion: z.ZodNumber | z.ZodLiteral<number>;
+}, TKindSuffix extends string = "">(_schema: z.ZodObject<TBaseShape>, kindSuffix: TKindSuffix): <TBaseSchema extends WidenZodObject<z.ZodObject<TBaseShape>>, TNamespace extends string | undefined = undefined, TKind extends string | undefined = undefined, TSchemaVersion extends number | undefined = undefined, TFields extends z.ZodRawShape = {}>(config: {
+    baseSchema: TBaseSchema;
+    namespace?: TNamespace;
+    kind?: TKind;
+    schemaVersion?: TSchemaVersion;
+    fields?: TFields;
+}) => (TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+    [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+    namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+    kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.${TKindSuffix}`>;
+    schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+}, z.core.$strip> : never) & {
+    new: (input: Omit<z.infer<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.${TKindSuffix}`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>, "kind" | "schemaVersion" | "namespace">) => z.infer<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.${TKindSuffix}`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>;
+    newWithId(input: Omit<z.infer<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.${TKindSuffix}`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>, "id" | "kind" | "schemaVersion" | "namespace">, generator: IdGenerator): Promise<z.infer<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.${TKindSuffix}`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>>;
+};

package/dist/schemas/score.d.ts

@@ -0,0 +1,73 @@
+import z from "zod";
+export declare const BaseScoreSchemaV1: z.ZodObject<{
+    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";
+    }>;
+}, z.core.$strip>;
+export type BaseScoreV1 = z.infer<typeof BaseScoreSchemaV1>;
+export declare const defineScoreSchema: <TBaseSchema extends import("../index.js").WidenZodObject<z.ZodObject<{
+    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";
+    }>;
+}, z.core.$strip>>, TNamespace extends string | undefined = undefined, TKind extends string | undefined = undefined, TSchemaVersion extends number | undefined = undefined, TFields extends Readonly<{
+    [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}> = {}>(config: {
+    baseSchema: TBaseSchema;
+    namespace?: TNamespace | undefined;
+    kind?: TKind | undefined;
+    schemaVersion?: TSchemaVersion | undefined;
+    fields?: TFields | undefined;
+}) => (TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+    [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+    namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+    kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.sc`>;
+    schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+}, z.core.$strip> : never) & {
+    new: (input: Omit<z.core.output<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.sc`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>, "kind" | "namespace" | "schemaVersion">) => z.core.output<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.sc`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>;
+    newWithId(input: Omit<z.core.output<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.sc`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>, "kind" | "id" | "namespace" | "schemaVersion">, generator: import("../types").IdGenerator): Promise<z.core.output<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.sc`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>>;
+};

package/dist/schemas/test-case.d.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+export declare const BaseTestCaseSchemaV1: z.ZodObject<{
+    id: z.ZodString;
+    namespace: z.ZodString;
+    schemaVersion: z.ZodNumber;
+    kind: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type BaseTestCaseV1 = z.infer<typeof BaseTestCaseSchemaV1>;
+export declare const defineTestCaseSchema: <TBaseSchema extends import("../index.js").WidenZodObject<z.ZodObject<{
+    id: z.ZodString;
+    namespace: z.ZodString;
+    schemaVersion: z.ZodNumber;
+    kind: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>>, TNamespace extends string | undefined = undefined, TKind extends string | undefined = undefined, TSchemaVersion extends number | undefined = undefined, TFields extends Readonly<{
+    [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}> = {}>(config: {
+    baseSchema: TBaseSchema;
+    namespace?: TNamespace | undefined;
+    kind?: TKind | undefined;
+    schemaVersion?: TSchemaVersion | undefined;
+    fields?: TFields | undefined;
+}) => (TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+    [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+    namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+    kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.tc`>;
+    schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+}, z.core.$strip> : never) & {
+    new: (input: Omit<z.core.output<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.tc`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>, "kind" | "namespace" | "schemaVersion">) => z.core.output<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.tc`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>;
+    newWithId(input: Omit<z.core.output<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.tc`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>, "kind" | "id" | "namespace" | "schemaVersion">, generator: import("../index.js").IdGenerator): Promise<z.core.output<TBaseSchema extends z.ZodObject<infer U extends Readonly<{
+        [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z.core.$strip> ? z.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z.ZodLiteral<`${TKind}.tc`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z.ZodLiteral<TSchemaVersion>;
+    }, z.core.$strip> : never>>;
+};

package/dist/{abstract-BdgLjkNC.d.ts → scorers/abstract.d.ts}

@@ -1,4 +1,4 @@
-declare abstract class AbstractScorer {
+export declare abstract class AbstractScorer {
     readonly kind: string;
     constructor();
     abstract score(params: any): Promise<BaseScorerResult | null>;
@@ -8,11 +8,9 @@ declare abstract class AbstractScorer {
         readonly kind: TKind;
     };
 }
-type BaseScorerResult = {
+export type BaseScorerResult = {
     value: number;
     explanation?: string;
     metadata?: Record<string, unknown>;
     [key: string]: unknown;
 };
-
-export { AbstractScorer as A, type BaseScorerResult as B };

package/dist/scorers/index.d.ts

@@ -1,68 +1,4 @@
-import { A as AbstractScorer } from '../abstract-BdgLjkNC.js';
-export { B as BaseScorerResult } from '../abstract-BdgLjkNC.js';
-export { b as LLMAsAJudgeCriterion, c as LLMAsAJudgeScoreParams, L as LLMAsAJudgeScorer, a as MCQScorer, M as MCQScorerParams } from '../llm-judge-BuF80-5-.js';
-import '../llm-8ecJmwKJ.js';
-import '../provider-DnEBdl1n.js';
-import 'openai/resources/shared';
-import 'openai/resources/chat/completions';
-import '../rate-limiter-CSmVIRsM.js';
-import 'zod';
-
-type RegexPattern = {
-    /**
-     * The regex pattern to match against the response
-     */
-    regex: RegExp;
-    /**
-     * The index of the capture group to extract (1-based, like match[1])
-     * If not provided, defaults to 1 (first capture group)
-     */
-    captureGroupIndex?: number;
-    /**
-     * Optional function to transform the extracted value before validation
-     */
-    transform?: (value: string) => string | undefined;
-};
-type RegexScorerParams = {
-    /**
-     * The input text to score
-     */
-    input: string;
-    /**
-     * Array of regex patterns to try (in order, first match wins)
-     */
-    patterns: RegexPattern[];
-    /**
-     * Expected value(s) to match against. Can be a record of expected values for named groups, or a validation function
-     */
-    expectedValue: Record<string, string> | ((groupName: string, match: string) => boolean);
-    /**
-     * Optional: Which match to use when multiple matches are found
-     * Defaults to "last" (uses the last match found)
-     */
-    matchPreference?: "first" | "last";
-    /**
-     * Optional: If true, allows partial scoring based on how many groups match
-     * For example, if 2 groups are expected and only 1 matches, score would be 0.5
-     * Defaults to false (all-or-nothing scoring)
-     */
-    allowPartialScoring?: boolean;
-};
-declare const RegexScorer_base: (new () => AbstractScorer & {
-    readonly kind: "peerbench.ai/regex";
-}) & {
-    readonly kind: "peerbench.ai/regex";
-};
-/**
- * Generic Regex scorer. It scores the given input against a set of regex patterns.
- */
-declare class RegexScorer extends RegexScorer_base {
-    score(params: RegexScorerParams): Promise<{
-        value: number;
-        extractedAnswers: {
-            [k: string]: string;
-        };
-    }>;
-}
-
-export { AbstractScorer, type RegexPattern, RegexScorer, type RegexScorerParams };
+export * from "./abstract";
+export * from "./mcq";
+export * from "./llm-judge";
+export * from "./regex";

package/dist/scorers/llm-judge.d.ts

@@ -0,0 +1,55 @@
+import { AbstractLLMProvider } from "../providers/abstract/llm";
+import { RateLimiter } from "../utils/rate-limiter";
+import { AbstractScorer, BaseScorerResult } from "./abstract";
+import z from "zod";
+declare const LLMAsAJudgeScorer_base: (new () => AbstractScorer & {
+    readonly kind: "peerbench.ai/llm-as-a-judge";
+}) & {
+    readonly kind: "peerbench.ai/llm-as-a-judge";
+};
+export declare class LLMAsAJudgeScorer extends LLMAsAJudgeScorer_base {
+    private provider;
+    constructor(config: {
+        provider: AbstractLLMProvider;
+        rateLimiter?: RateLimiter;
+    });
+    score<T extends z.ZodRawShape>(params: LLMAsAJudgeScoreParams & {
+        fieldsToExtract: T;
+    }): Promise<ScorerResultWithExtractedFields<T> | null>;
+    score(params: LLMAsAJudgeScoreParams & {
+        fieldsToExtract?: never;
+    }): Promise<ScorerResultWithoutExtractedFields | null>;
+}
+export type LLMAsAJudgeCriterion = {
+    id: string;
+    description: string;
+    weight: number;
+    scale?: {
+        min: number;
+        max: number;
+    };
+};
+export type LLMAsAJudgeScoreParams = {
+    model: string;
+    response: string;
+    rubric: string;
+    criteria: LLMAsAJudgeCriterion[];
+    systemPrompt?: string;
+    maxExplanationLength?: number;
+};
+type ScorerResultWithoutExtractedFields = BaseScorerResult & {
+    results: {
+        id: string;
+        score: number;
+        explanation: string;
+    }[];
+    provider: string;
+    inputTokensUsed?: number;
+    outputTokensUsed?: number;
+    inputCost?: string;
+    outputCost?: string;
+};
+type ScorerResultWithExtractedFields<T extends z.ZodRawShape> = ScorerResultWithoutExtractedFields & {
+    extractedFields: z.infer<z.ZodObject<T>>;
+};
+export {};

package/dist/scorers/mcq.d.ts

@@ -0,0 +1,19 @@
+import { AbstractScorer, BaseScorerResult } from "./abstract";
+export type MCQScorerParams = {
+    response: string;
+    choices: Record<string, string>;
+    correctAnswers: string[];
+};
+declare const MCQScorer_base: (new () => AbstractScorer & {
+    readonly kind: "peerbench.ai/mcq";
+}) & {
+    readonly kind: "peerbench.ai/mcq";
+};
+export declare class MCQScorer extends MCQScorer_base {
+    private regexScorer;
+    score(params: MCQScorerParams): Promise<BaseScorerResult & {
+        extractedAnswers: string[];
+    }>;
+    private buildPatternsForAnswer;
+}
+export {};

package/dist/scorers/mcq.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scorers/regex.d.ts

@@ -0,0 +1,58 @@
+import { AbstractScorer } from "./abstract";
+export type RegexPattern = {
+    /**
+     * The regex pattern to match against the response
+     */
+    regex: RegExp;
+    /**
+     * The index of the capture group to extract (1-based, like match[1])
+     * If not provided, defaults to 1 (first capture group)
+     */
+    captureGroupIndex?: number;
+    /**
+     * Optional function to transform the extracted value before validation
+     */
+    transform?: (value: string) => string | undefined;
+};
+export type RegexScorerParams = {
+    /**
+     * The input text to score
+     */
+    input: string;
+    /**
+     * Array of regex patterns to try (in order, first match wins)
+     */
+    patterns: RegexPattern[];
+    /**
+     * Expected value(s) to match against. Can be a record of expected values for named groups, or a validation function
+     */
+    expectedValue: Record<string, string> | ((groupName: string, match: string) => boolean);
+    /**
+     * Optional: Which match to use when multiple matches are found
+     * Defaults to "last" (uses the last match found)
+     */
+    matchPreference?: "first" | "last";
+    /**
+     * Optional: If true, allows partial scoring based on how many groups match
+     * For example, if 2 groups are expected and only 1 matches, score would be 0.5
+     * Defaults to false (all-or-nothing scoring)
+     */
+    allowPartialScoring?: boolean;
+};
+declare const RegexScorer_base: (new () => AbstractScorer & {
+    readonly kind: "peerbench.ai/regex";
+}) & {
+    readonly kind: "peerbench.ai/regex";
+};
+/**
+ * Generic Regex scorer. It scores the given input against a set of regex patterns.
+ */
+export declare class RegexScorer extends RegexScorer_base {
+    score(params: RegexScorerParams): Promise<{
+        value: number;
+        extractedAnswers: {
+            [k: string]: string;
+        };
+    }>;
+}
+export {};

package/dist/scorers/regex.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/storages/abstract.d.ts

@@ -0,0 +1,7 @@
+export declare abstract class AbstractStorage<TObject> {
+    abstract init(params?: unknown): Promise<void>;
+    abstract read(key: string, params?: unknown): Promise<TObject | null>;
+    abstract readAll(params?: unknown): Promise<TObject[]>;
+    abstract write(key: string, value: TObject, params?: unknown): Promise<unknown>;
+    count(): Promise<number>;
+}

package/dist/storages/examples/http.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/storages/examples/sqlite.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/storages/file.d.ts

@@ -0,0 +1,43 @@
+import { FileHandle } from "node:fs/promises";
+import { AbstractStorage } from "./abstract";
+export declare class FileStorage<TObject> extends AbstractStorage<TObject> {
+    protected path: string;
+    protected codec: AbstractFileStorageCodec<TObject>;
+    protected fileHandle: FileHandle | undefined;
+    constructor(config: {
+        path: string;
+        codec: AbstractFileStorageCodec<TObject>;
+    });
+    init(): Promise<void>;
+    read(_key: string, _params?: unknown): Promise<TObject | null>;
+    readAll(_params?: unknown): Promise<TObject[]>;
+    write(_key: string, _value: TObject, _params?: unknown): Promise<unknown>;
+    protected readChunks(params: {
+        startOffset?: number;
+        chunkSize: number;
+    }): AsyncIterable<{
+        offset: number;
+        bytes: Uint8Array;
+    }>;
+    protected size(): Promise<number>;
+    protected readAt(offset: number, length: number): Promise<Uint8Array>;
+    protected assertInitialized(): asserts this is this & {
+        fileHandle: FileHandle;
+    };
+}
+export type FileStorageFileHandle = {
+    size(): Promise<number>;
+    readAt(offset: number, length: number): Promise<Uint8Array>;
+    readChunks(params: {
+        startOffset?: number;
+        chunkSize: number;
+    }): AsyncIterable<{
+        offset: number;
+        bytes: Uint8Array;
+    }>;
+};
+export declare abstract class AbstractFileStorageCodec<TObject> {
+    abstract readAll(params: {
+        fileHandle: FileStorageFileHandle;
+    }): Promise<TObject[]>;
+}