peerbench 0.0.1 → 0.0.2-alpha-dev.0

package/dist/json-file-ZwzLUbje.d.ts

@@ -0,0 +1,73 @@
+import { FileHandle } from 'node:fs/promises';
+import z__default from 'zod';
+
+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>;
+}
+
+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;
+    };
+}
+type FileStorageFileHandle = {
+    size(): Promise<number>;
+    readAt(offset: number, length: number): Promise<Uint8Array>;
+    readChunks(params: {
+        startOffset?: number;
+        chunkSize: number;
+    }): AsyncIterable<{
+        offset: number;
+        bytes: Uint8Array;
+    }>;
+};
+declare abstract class AbstractFileStorageCodec<TObject> {
+    abstract readAll(params: {
+        fileHandle: FileStorageFileHandle;
+    }): Promise<TObject[]>;
+}
+
+declare class JSONFileStorage<TObject> extends FileStorage<TObject> {
+    codec: JSONFileStorageCodec<TObject>;
+    constructor(config: {
+        path: string;
+        chunkSize?: number;
+        schema: z__default.ZodType<TObject>;
+    });
+}
+declare class JSONFileStorageCodec<TObject> extends AbstractFileStorageCodec<TObject> {
+    private chunkSize;
+    private schema;
+    constructor(config: {
+        chunkSize?: number;
+        schema: z__default.ZodType<TObject>;
+    });
+    readAll(params: {
+        fileHandle: FileStorageFileHandle;
+    }): Promise<TObject[]>;
+}
+
+export { AbstractStorage as A, FileStorage as F, JSONFileStorage as J, JSONFileStorageCodec as a, type FileStorageFileHandle as b, AbstractFileStorageCodec as c };

package/dist/llm-DNj_tp2T.d.ts

@@ -0,0 +1,22 @@
+import { A as AbstractProvider, P as ProviderResponse } from './provider-BDjGp2y-.js';
+import { ResponseFormatText, ResponseFormatJSONSchema, ResponseFormatJSONObject } from 'openai/resources/shared';
+import { ChatCompletionMessageParam } from 'openai/resources/chat/completions';
+
+declare abstract class AbstractLLMProvider extends AbstractProvider {
+    abstract forward(args: LLMProviderForwardArgs): Promise<ChatResponse>;
+}
+type LLMProviderForwardArgs = {
+    messages: ChatCompletionMessageParam[];
+    model: string;
+    abortSignal?: AbortSignal;
+    temperature?: number;
+    responseFormat?: ResponseFormatText | ResponseFormatJSONSchema | ResponseFormatJSONObject;
+};
+type ChatResponse = ProviderResponse<string> & {
+    inputTokensUsed?: number;
+    outputTokensUsed?: number;
+    inputCost?: string;
+    outputCost?: string;
+};
+
+export { AbstractLLMProvider as A, type ChatResponse as C, type LLMProviderForwardArgs as L };

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

@@ -0,0 +1,67 @@
+import { A as AbstractScorer, B as BaseScorerResult } from './abstract-Dec9Sc5O.js';
+import { A as AbstractLLMProvider } from './llm-DNj_tp2T.js';
+import { R as RateLimiter } from './rate-limiter-CSmVIRsM.js';
+import z__default from 'zod';
+
+type MCQScorerParams = {
+    response: string;
+    choices: Record<string, string>;
+    correctAnswers: string[];
+};
+declare class MCQScorer extends AbstractScorer {
+    readonly kind: "peerbench.ai/mcq";
+    private regexScorer;
+    score(params: MCQScorerParams): Promise<BaseScorerResult & {
+        extractedAnswers: string[];
+    }>;
+    private buildPatternsForAnswer;
+}
+
+declare class LLMAsAJudgeScorer extends AbstractScorer {
+    readonly kind: "peerbench.ai/llm-as-a-judge";
+    private provider;
+    constructor(config: {
+        provider: AbstractLLMProvider;
+        rateLimiter?: RateLimiter;
+    });
+    score<T extends z__default.ZodRawShape>(params: LLMAsAJudgeScoreParams & {
+        fieldsToExtract: T;
+    }): Promise<ScorerResultWithExtractedFields<T> | null>;
+    score(params: LLMAsAJudgeScoreParams & {
+        fieldsToExtract?: never;
+    }): Promise<ScorerResultWithoutExtractedFields | null>;
+}
+type LLMAsAJudgeCriterion = {
+    id: string;
+    description: string;
+    weight: number;
+    scale?: {
+        min: number;
+        max: number;
+    };
+};
+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__default.ZodRawShape> = ScorerResultWithoutExtractedFields & {
+    extractedFields: z__default.infer<z__default.ZodObject<T>>;
+};
+
+export { LLMAsAJudgeScorer as L, type MCQScorerParams as M, MCQScorer as a, type LLMAsAJudgeCriterion as b, type LLMAsAJudgeScoreParams as c };

package/dist/provider-BDjGp2y-.d.ts

@@ -0,0 +1,10 @@
+declare abstract class AbstractProvider {
+    abstract readonly kind: string;
+}
+type ProviderResponse<TData = unknown> = {
+    startedAt: number;
+    completedAt: number;
+    data: TData;
+};
+
+export { AbstractProvider as A, type ProviderResponse as P };

package/dist/providers/index.d.ts

@@ -0,0 +1,69 @@
+import { A as AbstractLLMProvider, L as LLMProviderForwardArgs, C as ChatResponse } from '../llm-DNj_tp2T.js';
+export { A as AbstractProvider, P as ProviderResponse } from '../provider-BDjGp2y-.js';
+import { MastraClient } from '@mastra/client-js';
+import { R as RateLimiter } from '../rate-limiter-CSmVIRsM.js';
+import { ChatCompletionMessageParam } from 'openai/resources/chat/completions';
+import { ResponseFormatText, ResponseFormatJSONSchema, ResponseFormatJSONObject } from 'openai/resources/shared';
+
+declare class MastraProvider extends AbstractLLMProvider {
+    readonly kind = "mastra";
+    private readonly endpoint;
+    private readonly authToken?;
+    private client;
+    private warnedAboutSystemMessages;
+    private warnedAboutResponseFormat;
+    constructor(params: {
+        endpoint: string;
+        authToken?: string;
+    });
+    forward(args: LLMProviderForwardArgs & {
+        memory?: AgentMemoryOption;
+    }): Promise<ChatResponse>;
+}
+type AgentMemoryOption = Parameters<Parameters<MastraClient["getAgent"]>["0"] extends string ? ReturnType<MastraClient["getAgent"]>["generate"] : never>[0] extends {
+    memory?: infer M;
+} ? M : never;
+
+declare class OpenAIProvider extends AbstractLLMProvider {
+    readonly kind: "peerbench.ai/llm/openai";
+    private client;
+    private rateLimiter;
+    private maxRetries;
+    constructor(config: {
+        apiKey: string;
+        baseURL: string;
+        maxRetries?: number;
+        timeout?: number;
+        rateLimiter?: RateLimiter;
+    });
+    forward(args: {
+        messages: ChatCompletionMessageParam[];
+        model: string;
+        abortSignal?: AbortSignal;
+        temperature?: number;
+        responseFormat?: ResponseFormatText | ResponseFormatJSONSchema | ResponseFormatJSONObject;
+    }): Promise<ChatResponse>;
+}
+
+declare class OpenRouterProvider extends AbstractLLMProvider {
+    readonly kind: "peerbench.ai/llm/openrouter.ai";
+    private models;
+    private modelsCachePromise;
+    private modelsUpdatedAt;
+    private openAIProvider;
+    constructor(config: {
+        apiKey: string;
+        maxRetries?: number;
+        timeout?: number;
+        rateLimiter?: RateLimiter;
+    });
+    forward(args: LLMProviderForwardArgs): Promise<ChatResponse>;
+    /**
+     * Updates the cache that holds information about OpenRouter models
+     * including pricing information. It will be valid for 24 hours as
+     * long as the instance of this Provider object is alive.
+     */
+    private updateModelsCache;
+}
+
+export { AbstractLLMProvider, type AgentMemoryOption, ChatResponse, LLMProviderForwardArgs, MastraProvider, OpenAIProvider, OpenRouterProvider };

package/dist/providers/index.js

@@ -0,0 +1,18 @@
+import {
+  AbstractLLMProvider,
+  AbstractProvider,
+  MastraProvider,
+  OpenAIProvider,
+  OpenRouterProvider
+} from "../chunk-R76XA2K6.js";
+import "../chunk-UHHHSYVE.js";
+import "../chunk-4UBK6452.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  AbstractLLMProvider,
+  AbstractProvider,
+  MastraProvider,
+  OpenAIProvider,
+  OpenRouterProvider
+};
+//# sourceMappingURL=index.js.map

package/dist/providers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/rate-limiter-CSmVIRsM.d.ts

@@ -0,0 +1,60 @@
+interface RateLimiterOptions {
+    /**
+     * Maximum weight of calls allowed within a time window. Each call has a weight of 1 by default.
+     * Rate limiting is disabled when this is 0 or negative.
+     * @default 25
+     */
+    maxWeight?: number;
+    /**
+     * Time window in milliseconds for rate limiting
+     * @default 1000
+     */
+    timeWindow?: number;
+}
+interface RateLimiterCallOptions {
+    /**
+     * Weight of the call. Rate limiting is applied based on the total weight of the calls.
+     * @default 1
+     */
+    weight?: number;
+    /**
+     * Abort signal for cancellation
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Generic rate limiter. It can be used to limit async function calls
+ * by a given number of calls within a time window.
+ */
+declare class RateLimiter {
+    maxWeight: number;
+    timeWindow: number;
+    private timestamps;
+    constructor(options?: RateLimiterOptions);
+    /**
+     * Checks if rate limiting is disabled
+     */
+    isDisabled(): boolean;
+    /**
+     * Disables rate limiting. Set `maxWeight` to re-enable it.
+     */
+    disable(): void;
+    /**
+     * Returns how many weight of calls are there in the current time window
+     */
+    getCurrentCalls(): number;
+    /**
+     * Executes the given function with rate limiting applied
+     */
+    execute<T = unknown>(func: () => Promise<T>, { weight, signal }?: RateLimiterCallOptions): Promise<T>;
+    /**
+     * Waits until rate limit allows the specified weight of calls
+     */
+    private waitForRateLimit;
+    /**
+     * Resets the rate limited weight of calls
+     */
+    reset(): void;
+}
+
+export { RateLimiter as R, type RateLimiterOptions as a, type RateLimiterCallOptions as b };

package/dist/schemas/extensions/index.d.ts

@@ -0,0 +1,28 @@
+import * as z from 'zod';
+
+declare const ScoreExtensions: {
+    ExtensionLLMAsAJudgeScoreFieldsV1: {
+        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>;
+    };
+};
+declare const ResponseExtensions: {
+    ExtensionLLMResponseFieldsV1: {
+        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>;
+    };
+};
+
+export { ResponseExtensions, ScoreExtensions };

package/dist/schemas/extensions/index.js

@@ -0,0 +1,19 @@
+import {
+  ExtensionLLMAsAJudgeScoreFieldsV1,
+  ExtensionLLMResponseFieldsV1
+} from "../../chunk-TRNCF2BG.js";
+import "../../chunk-NUEOE3K5.js";
+import "../../chunk-PZ5AY32C.js";
+
+// src/schemas/extensions/index.ts
+var ScoreExtensions = {
+  ExtensionLLMAsAJudgeScoreFieldsV1
+};
+var ResponseExtensions = {
+  ExtensionLLMResponseFieldsV1
+};
+export {
+  ResponseExtensions,
+  ScoreExtensions
+};
+//# sourceMappingURL=index.js.map

package/dist/schemas/extensions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/schemas/extensions/index.ts"],"sourcesContent":["import { ExtensionLLMResponseFieldsV1 } from \"./response/llm\";\nimport { ExtensionLLMAsAJudgeScoreFieldsV1 } from \"./score/llm-as-a-judge-scorer\";\n\nexport const ScoreExtensions = {\n  ExtensionLLMAsAJudgeScoreFieldsV1,\n};\n\nexport const ResponseExtensions = {\n  ExtensionLLMResponseFieldsV1,\n};\n"],"mappings":";;;;;;;;AAGO,IAAM,kBAAkB;AAAA,EAC7B;AACF;AAEO,IAAM,qBAAqB;AAAA,EAChC;AACF;","names":[]}

package/dist/schemas/index.d.ts

@@ -0,0 +1,200 @@
+import { W as WidenZodObject, I as IdGenerator } from '../index-BAioQhp2.js';
+export { d as IdSchema } from '../index-BAioQhp2.js';
+import z__default, { z } from 'zod';
+import '../provider-BDjGp2y-.js';
+import '../abstract-Dec9Sc5O.js';
+
+declare const BaseResponseSchemaV1: z__default.ZodObject<{
+    id: z__default.ZodString;
+    namespace: z__default.ZodString;
+    schemaVersion: z__default.ZodNumber;
+    kind: z__default.ZodString;
+    startedAt: z__default.ZodNumber;
+    completedAt: z__default.ZodNumber;
+    testCaseId: z__default.ZodString;
+    metadata: z__default.ZodOptional<z__default.ZodRecord<z__default.ZodString, z__default.ZodUnknown>>;
+}, z__default.core.$strip>;
+type BaseResponseV1 = z__default.infer<typeof BaseResponseSchemaV1>;
+declare const defineResponseSchema: <TBaseSchema extends WidenZodObject<z__default.ZodObject<{
+    id: z__default.ZodString;
+    namespace: z__default.ZodString;
+    schemaVersion: z__default.ZodNumber;
+    kind: z__default.ZodString;
+    startedAt: z__default.ZodNumber;
+    completedAt: z__default.ZodNumber;
+    testCaseId: z__default.ZodString;
+    metadata: z__default.ZodOptional<z__default.ZodRecord<z__default.ZodString, z__default.ZodUnknown>>;
+}, z__default.core.$strip>>, TNamespace extends string | undefined = undefined, TKind extends string | undefined = undefined, TSchemaVersion extends number | undefined = undefined, TFields extends Readonly<{
+    [k: string]: z__default.core.$ZodType<unknown, unknown, z__default.core.$ZodTypeInternals<unknown, unknown>>;
+}> = {}>(config: {
+    baseSchema: TBaseSchema;
+    namespace?: TNamespace | undefined;
+    kind?: TKind | undefined;
+    schemaVersion?: TSchemaVersion | undefined;
+    fields?: TFields | undefined;
+}) => (TBaseSchema extends z__default.ZodObject<infer U extends Readonly<{
+    [k: string]: z__default.core.$ZodType<unknown, unknown, z__default.core.$ZodTypeInternals<unknown, unknown>>;
+}>, z__default.core.$strip> ? z__default.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+    namespace: TNamespace extends undefined ? U["namespace"] : z__default.ZodLiteral<TNamespace>;
+    kind: TKind extends undefined ? U["kind"] : z__default.ZodLiteral<`${TKind}.rs`>;
+    schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z__default.ZodLiteral<TSchemaVersion>;
+}, z__default.core.$strip> : never) & {
+    new: (input: Omit<z__default.core.output<TBaseSchema extends z__default.ZodObject<infer U extends Readonly<{
+        [k: string]: z__default.core.$ZodType<unknown, unknown, z__default.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z__default.core.$strip> ? z__default.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z__default.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z__default.ZodLiteral<`${TKind}.rs`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z__default.ZodLiteral<TSchemaVersion>;
+    }, z__default.core.$strip> : never>, "kind" | "namespace" | "schemaVersion">) => z__default.core.output<TBaseSchema extends z__default.ZodObject<infer U extends Readonly<{
+        [k: string]: z__default.core.$ZodType<unknown, unknown, z__default.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z__default.core.$strip> ? z__default.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z__default.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z__default.ZodLiteral<`${TKind}.rs`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z__default.ZodLiteral<TSchemaVersion>;
+    }, z__default.core.$strip> : never>;
+    newWithId(input: Omit<z__default.core.output<TBaseSchema extends z__default.ZodObject<infer U extends Readonly<{
+        [k: string]: z__default.core.$ZodType<unknown, unknown, z__default.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z__default.core.$strip> ? z__default.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z__default.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z__default.ZodLiteral<`${TKind}.rs`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z__default.ZodLiteral<TSchemaVersion>;
+    }, z__default.core.$strip> : never>, "id" | "kind" | "namespace" | "schemaVersion">, generator: IdGenerator): Promise<z__default.core.output<TBaseSchema extends z__default.ZodObject<infer U extends Readonly<{
+        [k: string]: z__default.core.$ZodType<unknown, unknown, z__default.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z__default.core.$strip> ? z__default.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z__default.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z__default.ZodLiteral<`${TKind}.rs`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z__default.ZodLiteral<TSchemaVersion>;
+    }, z__default.core.$strip> : never>>;
+};
+
+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>;
+type BaseTestCaseV1 = z.infer<typeof BaseTestCaseSchemaV1>;
+declare const defineTestCaseSchema: <TBaseSchema extends 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>, "id" | "kind" | "namespace" | "schemaVersion">, generator: 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>>;
+};
+
+declare const BaseScoreSchemaV1: z__default.ZodObject<{
+    id: z__default.ZodString;
+    namespace: z__default.ZodString;
+    kind: z__default.ZodString;
+    schemaVersion: z__default.ZodNumber;
+    value: z__default.ZodNumber;
+    responseId: z__default.ZodString;
+    explanation: z__default.ZodOptional<z__default.ZodString>;
+    metadata: z__default.ZodOptional<z__default.ZodRecord<z__default.ZodString, z__default.ZodUnknown>>;
+    scoringMethod: z__default.ZodEnum<{
+        readonly ai: "ai";
+        readonly human: "human";
+        readonly algo: "algo";
+    }>;
+}, z__default.core.$strip>;
+type BaseScoreV1 = z__default.infer<typeof BaseScoreSchemaV1>;
+declare const defineScoreSchema: <TBaseSchema extends WidenZodObject<z__default.ZodObject<{
+    id: z__default.ZodString;
+    namespace: z__default.ZodString;
+    kind: z__default.ZodString;
+    schemaVersion: z__default.ZodNumber;
+    value: z__default.ZodNumber;
+    responseId: z__default.ZodString;
+    explanation: z__default.ZodOptional<z__default.ZodString>;
+    metadata: z__default.ZodOptional<z__default.ZodRecord<z__default.ZodString, z__default.ZodUnknown>>;
+    scoringMethod: z__default.ZodEnum<{
+        readonly ai: "ai";
+        readonly human: "human";
+        readonly algo: "algo";
+    }>;
+}, z__default.core.$strip>>, TNamespace extends string | undefined = undefined, TKind extends string | undefined = undefined, TSchemaVersion extends number | undefined = undefined, TFields extends Readonly<{
+    [k: string]: z__default.core.$ZodType<unknown, unknown, z__default.core.$ZodTypeInternals<unknown, unknown>>;
+}> = {}>(config: {
+    baseSchema: TBaseSchema;
+    namespace?: TNamespace | undefined;
+    kind?: TKind | undefined;
+    schemaVersion?: TSchemaVersion | undefined;
+    fields?: TFields | undefined;
+}) => (TBaseSchema extends z__default.ZodObject<infer U extends Readonly<{
+    [k: string]: z__default.core.$ZodType<unknown, unknown, z__default.core.$ZodTypeInternals<unknown, unknown>>;
+}>, z__default.core.$strip> ? z__default.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+    namespace: TNamespace extends undefined ? U["namespace"] : z__default.ZodLiteral<TNamespace>;
+    kind: TKind extends undefined ? U["kind"] : z__default.ZodLiteral<`${TKind}.sc`>;
+    schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z__default.ZodLiteral<TSchemaVersion>;
+}, z__default.core.$strip> : never) & {
+    new: (input: Omit<z__default.core.output<TBaseSchema extends z__default.ZodObject<infer U extends Readonly<{
+        [k: string]: z__default.core.$ZodType<unknown, unknown, z__default.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z__default.core.$strip> ? z__default.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z__default.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z__default.ZodLiteral<`${TKind}.sc`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z__default.ZodLiteral<TSchemaVersion>;
+    }, z__default.core.$strip> : never>, "kind" | "namespace" | "schemaVersion">) => z__default.core.output<TBaseSchema extends z__default.ZodObject<infer U extends Readonly<{
+        [k: string]: z__default.core.$ZodType<unknown, unknown, z__default.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z__default.core.$strip> ? z__default.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z__default.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z__default.ZodLiteral<`${TKind}.sc`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z__default.ZodLiteral<TSchemaVersion>;
+    }, z__default.core.$strip> : never>;
+    newWithId(input: Omit<z__default.core.output<TBaseSchema extends z__default.ZodObject<infer U extends Readonly<{
+        [k: string]: z__default.core.$ZodType<unknown, unknown, z__default.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z__default.core.$strip> ? z__default.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z__default.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z__default.ZodLiteral<`${TKind}.sc`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z__default.ZodLiteral<TSchemaVersion>;
+    }, z__default.core.$strip> : never>, "id" | "kind" | "namespace" | "schemaVersion">, generator: IdGenerator): Promise<z__default.core.output<TBaseSchema extends z__default.ZodObject<infer U extends Readonly<{
+        [k: string]: z__default.core.$ZodType<unknown, unknown, z__default.core.$ZodTypeInternals<unknown, unknown>>;
+    }>, z__default.core.$strip> ? z__default.ZodObject<Omit<U, "kind" | "namespace" | "schemaVersion"> & TFields & {
+        namespace: TNamespace extends undefined ? U["namespace"] : z__default.ZodLiteral<TNamespace>;
+        kind: TKind extends undefined ? U["kind"] : z__default.ZodLiteral<`${TKind}.sc`>;
+        schemaVersion: TSchemaVersion extends undefined ? U["schemaVersion"] : z__default.ZodLiteral<TSchemaVersion>;
+    }, z__default.core.$strip> : never>>;
+};
+
+export { BaseResponseSchemaV1, type BaseResponseV1, BaseScoreSchemaV1, type BaseScoreV1, BaseTestCaseSchemaV1, type BaseTestCaseV1, defineResponseSchema, defineScoreSchema, defineTestCaseSchema };

package/dist/schemas/index.js

@@ -0,0 +1,24 @@
+import {
+  BaseResponseSchemaV1,
+  BaseScoreSchemaV1,
+  BaseTestCaseSchemaV1,
+  defineResponseSchema,
+  defineScoreSchema,
+  defineTestCaseSchema
+} from "../chunk-YY33MNMV.js";
+import "../chunk-OQE6TQXZ.js";
+import "../chunk-HMQYGCKI.js";
+import {
+  IdSchema
+} from "../chunk-NUEOE3K5.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  BaseResponseSchemaV1,
+  BaseScoreSchemaV1,
+  BaseTestCaseSchemaV1,
+  IdSchema,
+  defineResponseSchema,
+  defineScoreSchema,
+  defineTestCaseSchema
+};
+//# sourceMappingURL=index.js.map

package/dist/schemas/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}