@orq-ai/evaluators 1.0.9 → 1.1.0-rc.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orq-ai/evaluators",
-  "version": "1.0.9",
+  "version": "1.1.0-rc.2",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -50,6 +50,6 @@
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
-    "@orq-ai/evaluatorq": "^1.0.9"
+    "@orq-ai/evaluatorq": "^1.1.0-rc.2"
   }
 }

package/dist/lib/comparison-evaluators.d.ts

@@ -1,26 +0,0 @@
-import type { Evaluator } from "@orq-ai/evaluatorq";
-/**
- * Validates exact equality between output and expected output
- */
-export declare const exactMatch: Evaluator;
-/**
- * Validates fuzzy equality (case-insensitive, trimmed strings)
- */
-export declare const fuzzyMatch: Evaluator;
-/**
- * Validates that a numeric output is within a tolerance of the expected value
- */
-export declare function withinTolerance(tolerance: number): Evaluator;
-/**
- * Validates that a numeric output is greater than a threshold
- */
-export declare function greaterThan(threshold: number): Evaluator;
-/**
- * Validates that a numeric output is less than a threshold
- */
-export declare function lessThan(threshold: number): Evaluator;
-/**
- * Validates that a numeric output is within a range (inclusive)
- */
-export declare function inRange(min: number, max: number): Evaluator;
-//# sourceMappingURL=comparison-evaluators.d.ts.map

package/dist/lib/comparison-evaluators.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"comparison-evaluators.d.ts","sourceRoot":"","sources":["../../src/lib/comparison-evaluators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,SAmBxB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,SAqBxB,CAAC;AAEF;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAgC5D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAuBxD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAuBrD;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,CAuB3D"}

package/dist/lib/comparison-evaluators.js

@@ -1,148 +0,0 @@
-/**
- * Validates exact equality between output and expected output
- */
-export const exactMatch = {
-    name: "exact-match",
-    scorer: async ({ output, data }) => {
-        if (data.expectedOutput === undefined) {
-            return {
-                value: true,
-                explanation: "No expected output provided, skipping validation",
-            };
-        }
-        const matches = JSON.stringify(output) === JSON.stringify(data.expectedOutput);
-        return {
-            value: matches,
-            explanation: matches
-                ? "Output exactly matches expected"
-                : "Output does not match expected",
-        };
-    },
-};
-/**
- * Validates fuzzy equality (case-insensitive, trimmed strings)
- */
-export const fuzzyMatch = {
-    name: "fuzzy-match",
-    scorer: async ({ output, data }) => {
-        if (data.expectedOutput === undefined) {
-            return {
-                value: true,
-                explanation: "No expected output provided, skipping validation",
-            };
-        }
-        const outputStr = String(output).trim().toLowerCase();
-        const expectedStr = String(data.expectedOutput).trim().toLowerCase();
-        const matches = outputStr === expectedStr;
-        return {
-            value: matches,
-            explanation: matches
-                ? "Output matches expected (case-insensitive)"
-                : "Output does not match expected",
-        };
-    },
-};
-/**
- * Validates that a numeric output is within a tolerance of the expected value
- */
-export function withinTolerance(tolerance) {
-    return {
-        name: `within-tolerance-${tolerance}`,
-        scorer: async ({ output, data }) => {
-            if (data.expectedOutput === undefined) {
-                return {
-                    value: true,
-                    explanation: "No expected output provided, skipping validation",
-                };
-            }
-            const outputNum = Number(output);
-            const expectedNum = Number(data.expectedOutput);
-            if (Number.isNaN(outputNum) || Number.isNaN(expectedNum)) {
-                return {
-                    value: false,
-                    explanation: "Output or expected value is not a valid number",
-                };
-            }
-            const difference = Math.abs(outputNum - expectedNum);
-            const isWithinTolerance = difference <= tolerance;
-            return {
-                value: isWithinTolerance,
-                explanation: isWithinTolerance
-                    ? `Value ${outputNum} is within ${tolerance} of expected ${expectedNum}`
-                    : `Value ${outputNum} differs by ${difference} from expected ${expectedNum} (tolerance: ${tolerance})`,
-            };
-        },
-    };
-}
-/**
- * Validates that a numeric output is greater than a threshold
- */
-export function greaterThan(threshold) {
-    return {
-        name: `greater-than-${threshold}`,
-        scorer: async ({ output }) => {
-            const value = Number(output);
-            if (Number.isNaN(value)) {
-                return {
-                    value: false,
-                    explanation: "Output is not a valid number",
-                };
-            }
-            const isGreater = value > threshold;
-            return {
-                value: isGreater,
-                explanation: isGreater
-                    ? `Value ${value} is greater than ${threshold}`
-                    : `Value ${value} is not greater than ${threshold}`,
-            };
-        },
-    };
-}
-/**
- * Validates that a numeric output is less than a threshold
- */
-export function lessThan(threshold) {
-    return {
-        name: `less-than-${threshold}`,
-        scorer: async ({ output }) => {
-            const value = Number(output);
-            if (Number.isNaN(value)) {
-                return {
-                    value: false,
-                    explanation: "Output is not a valid number",
-                };
-            }
-            const isLess = value < threshold;
-            return {
-                value: isLess,
-                explanation: isLess
-                    ? `Value ${value} is less than ${threshold}`
-                    : `Value ${value} is not less than ${threshold}`,
-            };
-        },
-    };
-}
-/**
- * Validates that a numeric output is within a range (inclusive)
- */
-export function inRange(min, max) {
-    return {
-        name: `in-range-${min}-${max}`,
-        scorer: async ({ output }) => {
-            const value = Number(output);
-            if (Number.isNaN(value)) {
-                return {
-                    value: false,
-                    explanation: "Output is not a valid number",
-                };
-            }
-            const isInRange = value >= min && value <= max;
-            return {
-                value: isInRange,
-                explanation: isInRange
-                    ? `Value ${value} is within range [${min}, ${max}]`
-                    : `Value ${value} is outside range [${min}, ${max}]`,
-            };
-        },
-    };
-}

package/dist/lib/evaluators.d.ts

@@ -1,2 +0,0 @@
-export declare function evaluators(): string;
-//# sourceMappingURL=evaluators.d.ts.map

package/dist/lib/evaluators.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"evaluators.d.ts","sourceRoot":"","sources":["../../src/lib/evaluators.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,IAAI,MAAM,CAEnC"}

package/dist/lib/evaluators.js

@@ -1,3 +0,0 @@
-export function evaluators() {
-    return "evaluators";
-}

package/dist/lib/json-evaluators.d.ts

@@ -1,25 +0,0 @@
-import type { Evaluator } from "@orq-ai/evaluatorq";
-/**
- * Validates that the output is valid JSON
- */
-export declare const isValidJson: Evaluator;
-/**
- * Validates that the output contains specific JSON fields
- */
-export declare function hasJsonFields(requiredFields: string[]): Evaluator;
-/**
- * Validates JSON schema compliance
- */
-export declare function matchesJsonStructure(validator: (obj: any) => {
-    valid: boolean;
-    message?: string;
-}): Evaluator;
-/**
- * Validates that JSON array has a specific length
- */
-export declare function jsonArrayLength(expectedLength: number): Evaluator;
-/**
- * Validates that JSON array contains specific number of items within a range
- */
-export declare function jsonArrayLengthInRange(min: number, max: number): Evaluator;
-//# sourceMappingURL=json-evaluators.d.ts.map

package/dist/lib/json-evaluators.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"json-evaluators.d.ts","sourceRoot":"","sources":["../../src/lib/json-evaluators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,SAwBzB,CAAC;AAEF;;GAEG;AACH,wBAAgB,aAAa,CAAC,cAAc,EAAE,MAAM,EAAE,GAAG,SAAS,CA2CjE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CACnC,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAC3D,SAAS,CA2BX;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAqCjE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,CAqC1E"}

package/dist/lib/json-evaluators.js

@@ -1,177 +0,0 @@
-/**
- * Validates that the output is valid JSON
- */
-export const isValidJson = {
-    name: "is-valid-json",
-    scorer: async ({ output }) => {
-        if (output === undefined || output === null) {
-            return {
-                value: false,
-                explanation: "Output is null or undefined",
-            };
-        }
-        try {
-            const str = typeof output === "string" ? output : JSON.stringify(output);
-            JSON.parse(str);
-            return {
-                value: true,
-                explanation: "Output is valid JSON",
-            };
-        }
-        catch {
-            return {
-                value: false,
-                explanation: "Output is not valid JSON",
-            };
-        }
-    },
-};
-/**
- * Validates that the output contains specific JSON fields
- */
-export function hasJsonFields(requiredFields) {
-    const fieldList = requiredFields.join("-");
-    return {
-        name: `has-fields-${fieldList.slice(0, 30)}`,
-        scorer: async ({ output }) => {
-            if (output === undefined || output === null) {
-                return {
-                    value: false,
-                    explanation: "Output is null or undefined",
-                };
-            }
-            try {
-                const obj = typeof output === "string" ? JSON.parse(output) : output;
-                if (typeof obj !== "object" || Array.isArray(obj)) {
-                    return {
-                        value: false,
-                        explanation: "Output is not a JSON object",
-                    };
-                }
-                const missingFields = requiredFields.filter((field) => !(field in obj));
-                if (missingFields.length === 0) {
-                    return {
-                        value: true,
-                        explanation: `All required fields present: ${requiredFields.join(", ")}`,
-                    };
-                }
-                return {
-                    value: false,
-                    explanation: `Missing fields: ${missingFields.join(", ")}`,
-                };
-            }
-            catch {
-                return {
-                    value: false,
-                    explanation: "Output is not valid JSON",
-                };
-            }
-        },
-    };
-}
-/**
- * Validates JSON schema compliance
- */
-export function matchesJsonStructure(validator) {
-    return {
-        name: "matches-json-structure",
-        scorer: async ({ output }) => {
-            if (output === undefined || output === null) {
-                return {
-                    value: false,
-                    explanation: "Output is null or undefined",
-                };
-            }
-            try {
-                const obj = typeof output === "string" ? JSON.parse(output) : output;
-                const result = validator(obj);
-                return {
-                    value: result.valid,
-                    explanation: result.message || (result.valid ? "JSON structure is valid" : "JSON structure is invalid"),
-                };
-            }
-            catch (error) {
-                return {
-                    value: false,
-                    explanation: `Failed to parse JSON: ${error instanceof Error ? error.message : "Unknown error"}`,
-                };
-            }
-        },
-    };
-}
-/**
- * Validates that JSON array has a specific length
- */
-export function jsonArrayLength(expectedLength) {
-    return {
-        name: `json-array-length-${expectedLength}`,
-        scorer: async ({ output }) => {
-            if (output === undefined || output === null) {
-                return {
-                    value: false,
-                    explanation: "Output is null or undefined",
-                };
-            }
-            try {
-                const arr = typeof output === "string" ? JSON.parse(output) : output;
-                if (!Array.isArray(arr)) {
-                    return {
-                        value: false,
-                        explanation: "Output is not a JSON array",
-                    };
-                }
-                const hasExpectedLength = arr.length === expectedLength;
-                return {
-                    value: hasExpectedLength,
-                    explanation: hasExpectedLength
-                        ? `Array has expected length of ${expectedLength}`
-                        : `Array length ${arr.length} does not match expected ${expectedLength}`,
-                };
-            }
-            catch {
-                return {
-                    value: false,
-                    explanation: "Output is not valid JSON",
-                };
-            }
-        },
-    };
-}
-/**
- * Validates that JSON array contains specific number of items within a range
- */
-export function jsonArrayLengthInRange(min, max) {
-    return {
-        name: `json-array-length-${min}-${max}`,
-        scorer: async ({ output }) => {
-            if (output === undefined || output === null) {
-                return {
-                    value: false,
-                    explanation: "Output is null or undefined",
-                };
-            }
-            try {
-                const arr = typeof output === "string" ? JSON.parse(output) : output;
-                if (!Array.isArray(arr)) {
-                    return {
-                        value: false,
-                        explanation: "Output is not a JSON array",
-                    };
-                }
-                const isInRange = arr.length >= min && arr.length <= max;
-                return {
-                    value: isInRange,
-                    explanation: isInRange
-                        ? `Array length ${arr.length} is within range [${min}, ${max}]`
-                        : `Array length ${arr.length} is outside range [${min}, ${max}]`,
-                };
-            }
-            catch {
-                return {
-                    value: false,
-                    explanation: "Output is not valid JSON",
-                };
-            }
-        },
-    };
-}

package/dist/lib/string-evaluators.d.ts

@@ -1,30 +0,0 @@
-import type { Evaluator } from "@orq-ai/evaluatorq";
-/**
- * Validates that a string output does not exceed a maximum length
- */
-export declare function maxLength(max: number): Evaluator;
-/**
- * Validates that a string output meets a minimum length requirement
- */
-export declare function minLength(min: number): Evaluator;
-/**
- * Validates that the output contains a specific substring
- */
-export declare function contains(substring: string, caseSensitive?: boolean): Evaluator;
-/**
- * Validates that the output matches a regular expression pattern
- */
-export declare function matchesPattern(pattern: RegExp | string, description?: string): Evaluator;
-/**
- * Validates that the output starts with a specific prefix
- */
-export declare function startsWith(prefix: string): Evaluator;
-/**
- * Validates that the output ends with a specific suffix
- */
-export declare function endsWith(suffix: string): Evaluator;
-/**
- * Validates that the output is not empty or whitespace-only
- */
-export declare const notEmpty: Evaluator;
-//# sourceMappingURL=string-evaluators.d.ts.map

package/dist/lib/string-evaluators.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"string-evaluators.d.ts","sourceRoot":"","sources":["../../src/lib/string-evaluators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAsBhD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAsBhD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,aAAa,UAAO,GAAG,SAAS,CAyB3E;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CA0BxF;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAqBpD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAqBlD;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,SAkBtB,CAAC"}

package/dist/lib/string-evaluators.js

@@ -1,168 +0,0 @@
-/**
- * Validates that a string output does not exceed a maximum length
- */
-export function maxLength(max) {
-    return {
-        name: `max-length-${max}`,
-        scorer: async ({ output }) => {
-            if (output === undefined || output === null) {
-                return {
-                    value: false,
-                    explanation: "Output is null or undefined",
-                };
-            }
-            const length = typeof output === "string" ? output.length : String(output).length;
-            const isValid = length <= max;
-            return {
-                value: isValid,
-                explanation: isValid
-                    ? `Length ${length} is within limit (≤${max})`
-                    : `Length ${length} exceeds limit of ${max}`,
-            };
-        },
-    };
-}
-/**
- * Validates that a string output meets a minimum length requirement
- */
-export function minLength(min) {
-    return {
-        name: `min-length-${min}`,
-        scorer: async ({ output }) => {
-            if (output === undefined || output === null) {
-                return {
-                    value: false,
-                    explanation: "Output is null or undefined",
-                };
-            }
-            const length = typeof output === "string" ? output.length : String(output).length;
-            const isValid = length >= min;
-            return {
-                value: isValid,
-                explanation: isValid
-                    ? `Length ${length} meets minimum (≥${min})`
-                    : `Length ${length} is below minimum ${min}`,
-            };
-        },
-    };
-}
-/**
- * Validates that the output contains a specific substring
- */
-export function contains(substring, caseSensitive = true) {
-    return {
-        name: `contains-${substring.toLowerCase().replace(/\s+/g, "-")}`,
-        scorer: async ({ output }) => {
-            if (output === undefined || output === null) {
-                return {
-                    value: false,
-                    explanation: "Output is null or undefined",
-                };
-            }
-            const outputStr = String(output);
-            const searchStr = substring;
-            const found = caseSensitive
-                ? outputStr.includes(searchStr)
-                : outputStr.toLowerCase().includes(searchStr.toLowerCase());
-            return {
-                value: found,
-                explanation: found
-                    ? `Output contains "${substring}"`
-                    : `Output does not contain "${substring}"`,
-            };
-        },
-    };
-}
-/**
- * Validates that the output matches a regular expression pattern
- */
-export function matchesPattern(pattern, description) {
-    const regex = typeof pattern === "string" ? new RegExp(pattern) : pattern;
-    const patternStr = regex.source;
-    return {
-        name: `matches-pattern-${patternStr.slice(0, 20).replace(/[^a-z0-9]/gi, "-")}`,
-        scorer: async ({ output }) => {
-            if (output === undefined || output === null) {
-                return {
-                    value: false,
-                    explanation: "Output is null or undefined",
-                };
-            }
-            const matches = regex.test(String(output));
-            return {
-                value: matches,
-                explanation: matches
-                    ? description || `Output matches pattern /${patternStr}/`
-                    : description
-                        ? `Output does not match required pattern: ${description}`
-                        : `Output does not match pattern /${patternStr}/`,
-            };
-        },
-    };
-}
-/**
- * Validates that the output starts with a specific prefix
- */
-export function startsWith(prefix) {
-    return {
-        name: `starts-with-${prefix.toLowerCase().replace(/\s+/g, "-")}`,
-        scorer: async ({ output }) => {
-            if (output === undefined || output === null) {
-                return {
-                    value: false,
-                    explanation: "Output is null or undefined",
-                };
-            }
-            const starts = String(output).startsWith(prefix);
-            return {
-                value: starts,
-                explanation: starts
-                    ? `Output starts with "${prefix}"`
-                    : `Output does not start with "${prefix}"`,
-            };
-        },
-    };
-}
-/**
- * Validates that the output ends with a specific suffix
- */
-export function endsWith(suffix) {
-    return {
-        name: `ends-with-${suffix.toLowerCase().replace(/\s+/g, "-")}`,
-        scorer: async ({ output }) => {
-            if (output === undefined || output === null) {
-                return {
-                    value: false,
-                    explanation: "Output is null or undefined",
-                };
-            }
-            const ends = String(output).endsWith(suffix);
-            return {
-                value: ends,
-                explanation: ends
-                    ? `Output ends with "${suffix}"`
-                    : `Output does not end with "${suffix}"`,
-            };
-        },
-    };
-}
-/**
- * Validates that the output is not empty or whitespace-only
- */
-export const notEmpty = {
-    name: "not-empty",
-    scorer: async ({ output }) => {
-        if (output === undefined || output === null) {
-            return {
-                value: false,
-                explanation: "Output is null or undefined",
-            };
-        }
-        const trimmed = String(output).trim();
-        const isNotEmpty = trimmed.length > 0;
-        return {
-            value: isNotEmpty,
-            explanation: isNotEmpty ? "Output is not empty" : "Output is empty or whitespace-only",
-        };
-    },
-};