peerbench 0.0.6 → 0.0.8

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/scorers/abstract.d.ts

@@ -0,0 +1,16 @@
+export declare abstract class AbstractScorer {
+    readonly kind: string;
+    constructor();
+    abstract score(params: any): Promise<BaseScorerResult | null>;
+    static withKind<TKind extends string, TThis extends abstract new (...args: any[]) => AbstractScorer>(this: TThis, kind: TKind): (new () => InstanceType<TThis> & {
+        readonly kind: TKind;
+    }) & {
+        readonly kind: TKind;
+    };
+}
+export type BaseScorerResult = {
+    value: number;
+    explanation?: string;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+};

package/dist/scorers/index.d.ts

@@ -1,64 +1,4 @@
-import { A as AbstractScorer } from '../abstract-Dec9Sc5O.js';
-export { B as BaseScorerResult } from '../abstract-Dec9Sc5O.js';
-export { b as LLMAsAJudgeCriterion, c as LLMAsAJudgeScoreParams, L as LLMAsAJudgeScorer, a as MCQScorer, M as MCQScorerParams } from '../llm-judge-BS_oNYUK.js';
-import '../llm-BND163ns.js';
-import '../provider-BDjGp2y-.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;
-};
-/**
- * Generic Regex scorer. It scores the given input against a set of regex patterns.
- */
-declare class RegexScorer extends AbstractScorer {
-    readonly kind: "peerbench.ai/regex";
-    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/index.js

@@ -3,7 +3,7 @@ import {
   LLMAsAJudgeScorer,
   MCQScorer,
   RegexScorer
-} from "../chunk-DNGT4SJC.js";
+} from "../chunk-3JHDJEY3.js";
 import "../chunk-UHHHSYVE.js";
 import "../chunk-4UBK6452.js";
 import "../chunk-PZ5AY32C.js";

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[]>;
+}

package/dist/storages/http.d.ts

@@ -0,0 +1,22 @@
+import { AbstractStorage } from "../storages/abstract";
+export declare class HttpStorage<TObject> extends AbstractStorage<TObject> {
+    protected readonly url: string;
+    protected readonly codec: AbstractHttpStorageCodec<TObject>;
+    protected readonly fetchFn: typeof fetch;
+    constructor(config: {
+        url: string;
+        codec: AbstractHttpStorageCodec<TObject>;
+        fetchFn?: typeof fetch;
+    });
+    init(_params?: unknown): Promise<void>;
+    read(_key: string, _params?: unknown): Promise<TObject | null>;
+    readAll(params?: unknown): Promise<TObject[]>;
+    write(_key: string, _value: TObject, _params?: unknown): Promise<unknown>;
+}
+export declare abstract class AbstractHttpStorageCodec<TObject> {
+    abstract readAll(params: {
+        url: string;
+        response: Response;
+        params?: unknown;
+    }): Promise<TObject[]>;
+}

package/dist/storages/index.d.ts

@@ -1,69 +1,5 @@
-import { A as AbstractStorage } from '../json-file-Bgv9TLcX.js';
-export { c as AbstractFileStorageCodec, F as FileStorage, b as FileStorageFileHandle, J as JSONFileStorage, a as JSONFileStorageCodec } from '../json-file-Bgv9TLcX.js';
-import * as better_sqlite3 from 'better-sqlite3';
-import 'node:fs/promises';
-import 'zod';
-
-declare class HttpStorage<TObject> extends AbstractStorage<TObject> {
-    protected readonly url: string;
-    protected readonly codec: AbstractHttpStorageCodec<TObject>;
-    protected readonly fetchFn: typeof fetch;
-    constructor(config: {
-        url: string;
-        codec: AbstractHttpStorageCodec<TObject>;
-        fetchFn?: typeof fetch;
-    });
-    init(_params?: unknown): Promise<void>;
-    read(_key: string, _params?: unknown): Promise<TObject | null>;
-    readAll(params?: unknown): Promise<TObject[]>;
-    write(_key: string, _value: TObject, _params?: unknown): Promise<unknown>;
-}
-declare abstract class AbstractHttpStorageCodec<TObject> {
-    abstract readAll(params: {
-        url: string;
-        response: Response;
-        params?: unknown;
-    }): Promise<TObject[]>;
-}
-
-declare class SQLiteStorage<TObject> extends AbstractStorage<TObject> {
-    protected readonly path: string;
-    protected readonly codec: AbstractSQLiteStorageCodec<TObject>;
-    protected db: SQLiteDatabase | undefined;
-    constructor(config: {
-        path: string;
-        codec: AbstractSQLiteStorageCodec<TObject>;
-    });
-    init(params?: unknown): Promise<void>;
-    read(key: string, params?: unknown): Promise<TObject | null>;
-    readAll(params?: unknown): Promise<TObject[]>;
-    write(key: string, value: TObject, params?: unknown): Promise<unknown>;
-    close(): void;
-    protected assertInitialized(): asserts this is this & {
-        db: SQLiteDatabase;
-    };
-}
-declare abstract class AbstractSQLiteStorageCodec<TObject> {
-    init?(params: {
-        db: SQLiteDatabase;
-        params?: unknown;
-    }): Promise<void> | void;
-    abstract read(params: {
-        db: SQLiteDatabase;
-        key: string;
-        params?: unknown;
-    }): Promise<TObject | null>;
-    abstract readAll(params: {
-        db: SQLiteDatabase;
-        params?: unknown;
-    }): Promise<TObject[]>;
-    abstract write(params: {
-        db: SQLiteDatabase;
-        key: string;
-        value: TObject;
-        params?: unknown;
-    }): Promise<unknown>;
-}
-type SQLiteDatabase = better_sqlite3.Database;
-
-export { AbstractHttpStorageCodec, AbstractSQLiteStorageCodec, AbstractStorage, HttpStorage, SQLiteStorage };
+export * from "./abstract";
+export * from "./http";
+export * from "./json-file";
+export * from "./file";
+export * from "./sqlite";

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

@@ -0,0 +1,21 @@
+import { AbstractFileStorageCodec, FileStorage, FileStorageFileHandle } from "./file";
+import z from "zod";
+export declare class JSONFileStorage<TObject> extends FileStorage<TObject> {
+    codec: JSONFileStorageCodec<TObject>;
+    constructor(config: {
+        path: string;
+        chunkSize?: number;
+        schema: z.ZodType<TObject>;
+    });
+}
+export declare class JSONFileStorageCodec<TObject> extends AbstractFileStorageCodec<TObject> {
+    private chunkSize;
+    private schema;
+    constructor(config: {
+        chunkSize?: number;
+        schema: z.ZodType<TObject>;
+    });
+    readAll(params: {
+        fileHandle: FileStorageFileHandle;
+    }): Promise<TObject[]>;
+}

package/dist/storages/sqlite.d.ts

@@ -0,0 +1,41 @@
+import { AbstractStorage } from "../storages/abstract";
+export declare class SQLiteStorage<TObject> extends AbstractStorage<TObject> {
+    protected readonly path: string;
+    protected readonly codec: AbstractSQLiteStorageCodec<TObject>;
+    protected db: SQLiteDatabase | undefined;
+    constructor(config: {
+        path: string;
+        codec: AbstractSQLiteStorageCodec<TObject>;
+    });
+    init(params?: unknown): Promise<void>;
+    read(key: string, params?: unknown): Promise<TObject | null>;
+    readAll(params?: unknown): Promise<TObject[]>;
+    write(key: string, value: TObject, params?: unknown): Promise<unknown>;
+    close(): void;
+    protected assertInitialized(): asserts this is this & {
+        db: SQLiteDatabase;
+    };
+}
+export declare abstract class AbstractSQLiteStorageCodec<TObject> {
+    init?(params: {
+        db: SQLiteDatabase;
+        params?: unknown;
+    }): Promise<void> | void;
+    abstract read(params: {
+        db: SQLiteDatabase;
+        key: string;
+        params?: unknown;
+    }): Promise<TObject | null>;
+    abstract readAll(params: {
+        db: SQLiteDatabase;
+        params?: unknown;
+    }): Promise<TObject[]>;
+    abstract write(params: {
+        db: SQLiteDatabase;
+        key: string;
+        value: TObject;
+        params?: unknown;
+    }): Promise<unknown>;
+}
+type SQLiteDatabase = import("better-sqlite3").Database;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,17 @@
+export * from "./runner";
+import { AbstractProvider } from "../providers/index.js";
+import { IdSchema } from "../schemas/id";
+import { AbstractScorer } from "../scorers/abstract";
+import { AbstractClassConstructor, ClassConstructor } from "../utilities";
+import z from "zod";
+export type Id = z.infer<typeof IdSchema>;
+export type IdGenerator<TInput = unknown> = (input: TInput) => MaybePromise<Id>;
+export type MaybePromise<T> = T | Promise<T>;
+export declare const ScoringMethod: {
+    readonly ai: "ai";
+    readonly human: "human";
+    readonly algo: "algo";
+};
+export type ScoringMethod = (typeof ScoringMethod)[keyof typeof ScoringMethod];
+export type ScorerCtor = ClassConstructor<AbstractScorer> | AbstractClassConstructor<AbstractScorer>;
+export type ProviderCtor = ClassConstructor<AbstractProvider> | AbstractClassConstructor<AbstractProvider>;

package/dist/types/runner.d.ts

@@ -0,0 +1,18 @@
+import { AbstractProvider } from "../providers/index.js";
+import { AbstractScorer } from "../scorers/index.js";
+import { IdGenerator } from ".";
+import z from "zod";
+export type Runner<TTestCase extends z.ZodObject, TResponse extends z.ZodObject, TScore extends z.ZodObject, TProvider extends AbstractProvider, TScorer extends AbstractScorer, TRunConfig extends Record<string, unknown>> = (params: {
+    testCase: z.infer<TTestCase>;
+    provider: TProvider;
+    scorer?: TScorer;
+    runConfig: TRunConfig;
+    idGenerators?: {
+        response?: IdGenerator;
+        score?: IdGenerator;
+    };
+}) => Promise<{
+    response: z.infer<TResponse>;
+    score?: z.infer<TScore>;
+}>;
+export type InferRunConfig<TRunConfigSchema extends z.ZodRawShape> = z.infer<z.ZodObject<TRunConfigSchema>>;

package/dist/utilities.d.ts

@@ -0,0 +1,9 @@
+import type { z } from "zod";
+export type ClassConstructor<T> = new (...args: any[]) => T;
+export type AbstractClassConstructor<T> = abstract new (...args: any[]) => T;
+export type InferExtension<TExtension extends z.ZodRawShape, TBase = unknown> = z.infer<z.ZodObject<TExtension>> & TBase;
+type WidenLiteralSchema<S> = S extends z.ZodString ? z.ZodString | z.ZodLiteral<string> : S extends z.ZodNumber ? z.ZodNumber | z.ZodLiteral<number> : S extends z.ZodBoolean ? z.ZodBoolean | z.ZodLiteral<boolean> : S extends z.ZodLiteral<infer L> ? L extends string ? z.ZodString | z.ZodLiteral<L> : L extends number ? z.ZodNumber | z.ZodLiteral<L> : L extends boolean ? z.ZodBoolean | z.ZodLiteral<L> : S : S extends z.ZodOptional<infer O> ? z.ZodOptional<WidenLiteralSchema<O>> : S extends z.ZodType ? S : never;
+export type WidenZodObject<T extends z.ZodObject> = z.ZodObject<{
+    [K in keyof T["shape"]]: WidenLiteralSchema<T["shape"][K]>;
+}>;
+export {};

package/dist/utils/id-generator.d.ts

@@ -0,0 +1,2 @@
+import { IdGenerator } from "../types";
+export declare const idGeneratorUUIDv7: IdGenerator;

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./sleep";
+export * from "./llm";
+export * from "./rate-limiter";
+export * from "./string";
+export * from "./id-generator";

package/dist/utils/json.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Parses JSONL formatted string into an array
+ * @returns An array of parsed JSON lines
+ */
+export declare function parseJSONL<T>(str: string, options?: {
+    errorOnInvalid?: boolean;
+}): T[];
+/**
+ * Tries to parse the given string as JSON.
+ * Returns `undefined` if it is not a valid JSON entity.
+ */
+export declare function tryParseJson<T = any>(content: string): T | undefined;
+/**
+ * Stringifies the given JSON value using `safe-stable-stringify` in a stable manner.
+ * This stable method generates the same string output for the same input value (including objects).
+ */
+export declare function stableStringify(value: any): string | undefined;

package/dist/utils/llm.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tries to repair and parse LLM response as a JSON object. LLM must
+ * be configured to return a JSON object. This function only helps to
+ * get rid out of some additional formatting (e.g. ```json) and repair
+ * the JSON syntax (e.g missing comma, single quotes instead double).
+ */
+export declare function parseResponseAsJSON<T>(response: string): T | undefined;

package/dist/{rate-limiter-CSmVIRsM.d.ts → utils/rate-limiter.d.ts}

@@ -1,4 +1,4 @@
-interface RateLimiterOptions {
+export 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.
@@ -11,7 +11,7 @@ interface RateLimiterOptions {
      */
     timeWindow?: number;
 }
-interface RateLimiterCallOptions {
+export interface RateLimiterCallOptions {
     /**
      * Weight of the call. Rate limiting is applied based on the total weight of the calls.
      * @default 1
@@ -26,7 +26,7 @@ interface RateLimiterCallOptions {
  * 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 {
+export declare class RateLimiter {
     maxWeight: number;
     timeWindow: number;
     private timestamps;
@@ -56,5 +56,3 @@ declare class RateLimiter {
      */
     reset(): void;
 }
-
-export { RateLimiter as R, type RateLimiterOptions as a, type RateLimiterCallOptions as b };

package/dist/utils/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;

package/dist/utils/string.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts the given byte array to a string
+ */
+export declare function bufferToString(buffer: Uint8Array, encoding?: BufferEncoding): string;
+/**
+ * Converts the given string to a byte array
+ */
+export declare function stringToBuffer(str: string): Uint8Array;