@arizeai/phoenix-evals 0.5.0 → 0.6.0

package/dist/esm/utils/bindEvaluator.js

@@ -0,0 +1,163 @@
+/**
+ * Binds an evaluator to a specific data structure using input mapping.
+ *
+ * This function creates a new evaluator instance that automatically transforms
+ * your data structure to match what the evaluator expects. This is particularly
+ * useful when your data schema doesn't match the evaluator's expected input format.
+ *
+ * @param evaluator - The evaluator to bind (e.g., a hallucination evaluator)
+ * @param context - The binding context containing the input mapping configuration
+ * @returns A new evaluator instance with the input mapping applied
+ *
+ * @example
+ * **Basic usage with simple field mapping:**
+ * ```typescript
+ * import { bindEvaluator, createHallucinationEvaluator } from "@arizeai/phoenix-evals";
+ * import { openai } from "@ai-sdk/openai";
+ *
+ * type MyData = {
+ *   question: string;
+ *   context: string;
+ *   answer: string;
+ * };
+ *
+ * const evaluator = bindEvaluator<MyData>(
+ *   createHallucinationEvaluator({ model: openai("gpt-4") }),
+ *   {
+ *     inputMapping: {
+ *       input: "question",      // Evaluator expects "input", map from "question"
+ *       reference: "context",   // Evaluator expects "reference", map from "context"
+ *       output: "answer",        // Evaluator expects "output", map from "answer"
+ *     },
+ *   }
+ * );
+ *
+ * // Now you can evaluate with your data structure
+ * const result = await evaluator.evaluate({
+ *   question: "What is AI?",
+ *   context: "AI is artificial intelligence...",
+ *   answer: "AI stands for artificial intelligence",
+ * });
+ * ```
+ *
+ * @example
+ * **Using nested property access:**
+ * ```typescript
+ * type ApiResponse = {
+ *   request: {
+ *     body: {
+ *       query: string;
+ *       context: string;
+ *     };
+ *   };
+ *   response: {
+ *     data: {
+ *       text: string;
+ *     };
+ *   };
+ * };
+ *
+ * const evaluator = bindEvaluator<ApiResponse>(
+ *   createHallucinationEvaluator({ model: openai("gpt-4") }),
+ *   {
+ *     inputMapping: {
+ *       input: "request.body.query",
+ *       reference: "request.body.context",
+ *       output: "response.data.text",
+ *     },
+ *   }
+ * );
+ * ```
+ *
+ * @example
+ * **Using function-based mapping for data transformation:**
+ * ```typescript
+ * type RawData = {
+ *   question: string;
+ *   contexts: string[];  // Array of context strings
+ *   answer: string;
+ * };
+ *
+ * const evaluator = bindEvaluator<RawData>(
+ *   createHallucinationEvaluator({ model: openai("gpt-4") }),
+ *   {
+ *     inputMapping: {
+ *       input: "question",
+ *       // Transform array to single string
+ *       reference: (data) => data.contexts.join("\n\n"),
+ *       output: "answer",
+ *     },
+ *   }
+ * );
+ * ```
+ *
+ * @example
+ * **Using JSONPath for complex queries:**
+ * ```typescript
+ * type ComplexData = {
+ *   conversation: {
+ *     messages: Array<{ role: string; content: string }>;
+ *   };
+ *   metadata: {
+ *     sources: string[];
+ *   };
+ * };
+ *
+ * const evaluator = bindEvaluator<ComplexData>(
+ *   createHallucinationEvaluator({ model: openai("gpt-4") }),
+ *   {
+ *     inputMapping: {
+ *       // Extract last user message
+ *       input: "$.conversation.messages[?(@.role=='user')].content[-1]",
+ *       // Extract all sources
+ *       reference: "$.metadata.sources[*]",
+ *       // Extract last assistant message
+ *       output: "$.conversation.messages[?(@.role=='assistant')].content[-1]",
+ *     },
+ *   }
+ * );
+ * ```
+ *
+ * @example
+ * **Binding multiple evaluators with different mappings:**
+ * ```typescript
+ * type EvaluationData = {
+ *   userQuery: string;
+ *   systemContext: string;
+ *   modelOutput: string;
+ *   expectedOutput?: string;
+ * };
+ *
+ * // Hallucination evaluator
+ * const hallucinationEvaluator = bindEvaluator<EvaluationData>(
+ *   createHallucinationEvaluator({ model: openai("gpt-4") }),
+ *   {
+ *     inputMapping: {
+ *       input: "userQuery",
+ *       reference: "systemContext",
+ *       output: "modelOutput",
+ *     },
+ *   }
+ * );
+ *
+ * // Document relevancy evaluator (if it exists)
+ * const relevancyEvaluator = bindEvaluator<EvaluationData>(
+ *   createDocumentRelevancyEvaluator({ model: openai("gpt-4") }),
+ *   {
+ *     inputMapping: {
+ *       query: "userQuery",
+ *       document: "systemContext",
+ *       output: "modelOutput",
+ *     },
+ *   }
+ * );
+ * ```
+ */
+export function bindEvaluator(evaluator, context) {
+    let boundEvaluator = evaluator;
+    if (context.inputMapping) {
+        boundEvaluator = boundEvaluator.bindInputMapping(context.inputMapping);
+    }
+    return boundEvaluator;
+}
+//# sourceMappingURL=bindEvaluator.js.map

package/dist/esm/utils/bindEvaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bindEvaluator.js","sourceRoot":"","sources":["../../../src/utils/bindEvaluator.ts"],"names":[],"mappings":"AAgEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0JG;AACH,MAAM,UAAU,aAAa,CAC3B,SAAoC,EACpC,OAAmC;IAEnC,IAAI,cAAc,GAA8B,SAAS,CAAC;IAC1D,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;QACzB,cAAc,GAAG,cAAc,CAAC,gBAAgB,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;IACzE,CAAC;IACD,OAAO,cAAc,CAAC;AACxB,CAAC"}

package/dist/esm/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./bindEvaluator.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC"}

package/dist/esm/utils/index.js

@@ -0,0 +1,2 @@
+export * from "./bindEvaluator.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC"}

package/dist/esm/utils/objectMappingUtils.d.ts

@@ -0,0 +1,166 @@
+import { ObjectMapping } from "../types/data.js";
+/**
+ * Remaps an object by applying field mappings while preserving original data.
+ *
+ * This function takes your original data object and a mapping configuration,
+ * then returns a new object that contains:
+ * - All original fields from the input data
+ * - Additional/overridden fields based on the mapping
+ *
+ * The mapping allows you to extract values using:
+ * - Simple property names: `"fieldName"`
+ * - Dot notation: `"user.profile.name"`
+ * - Array access: `"items[0].id"`
+ * - JSONPath expressions: `"$.items[*].id"`
+ * - Function extractors: `(data) => data.customField`
+ *
+ * @param data - The input data object to remap
+ * @param mapping - The mapping configuration defining how to extract/transform values
+ * @returns A new object with original fields plus mapped fields
+ *
+ * @example
+ * **Basic remapping:**
+ * ```typescript
+ * const data = {
+ *   name: "John",
+ *   age: 30,
+ *   email: "john@example.com",
+ * };
+ *
+ * const mapping: ObjectMapping<typeof data> = {
+ *   userName: "name",
+ *   userAge: "age",
+ * };
+ *
+ * const result = remapObject(data, mapping);
+ * // Result: {
+ * //   name: "John",
+ * //   age: 30,
+ * //   email: "john@example.com",
+ * //   userName: "John",      // Added from mapping
+ * //   userAge: 30,            // Added from mapping
+ * // }
+ * ```
+ *
+ * @example
+ * **Nested property extraction:**
+ * ```typescript
+ * const data = {
+ *   user: {
+ *     profile: {
+ *       firstName: "John",
+ *       lastName: "Doe",
+ *     },
+ *     email: "john@example.com",
+ *   },
+ * };
+ *
+ * const mapping: ObjectMapping<typeof data> = {
+ *   firstName: "user.profile.firstName",
+ *   lastName: "user.profile.lastName",
+ *   email: "user.email",
+ * };
+ *
+ * const result = remapObject(data, mapping);
+ * // Result includes original data plus:
+ * // {
+ * //   firstName: "John",
+ * //   lastName: "Doe",
+ * //   email: "john@example.com",
+ * // }
+ * ```
+ *
+ * @example
+ * **Array element access:**
+ * ```typescript
+ * const data = {
+ *   items: [
+ *     { id: 1, name: "Apple" },
+ *     { id: 2, name: "Banana" },
+ *   ],
+ * };
+ *
+ * const mapping: ObjectMapping<typeof data> = {
+ *   firstItemId: "items[0].id",
+ *   firstItemName: "items[0].name",
+ * };
+ *
+ * const result = remapObject(data, mapping);
+ * // Result includes:
+ * // {
+ * //   firstItemId: 1,
+ * //   firstItemName: "Apple",
+ * // }
+ * ```
+ *
+ * @example
+ * **Function-based transformation:**
+ * ```typescript
+ * const data = {
+ *   firstName: "John",
+ *   lastName: "Doe",
+ *   scores: [85, 92, 78],
+ * };
+ *
+ * const mapping: ObjectMapping<typeof data> = {
+ *   fullName: (data) => `${data.firstName} ${data.lastName}`,
+ *   averageScore: (data) =>
+ *     data.scores.reduce((a, b) => a + b, 0) / data.scores.length,
+ * };
+ *
+ * const result = remapObject(data, mapping);
+ * // Result includes:
+ * // {
+ * //   fullName: "John Doe",
+ * //   averageScore: 85,
+ * // }
+ * ```
+ *
+ * @example
+ * **Field override:**
+ * ```typescript
+ * const data = {
+ *   name: "John",
+ *   status: "inactive",
+ * };
+ *
+ * const mapping: ObjectMapping<typeof data> = {
+ *   // Override existing field
+ *   status: (data) => data.name === "John" ? "active" : "inactive",
+ *   // Add new field
+ *   displayName: (data) => `User: ${data.name}`,
+ * };
+ *
+ * const result = remapObject(data, mapping);
+ * // Result:
+ * // {
+ * //   name: "John",
+ * //   status: "active",        // Overridden
+ * //   displayName: "User: John", // Added
+ * // }
+ * ```
+ *
+ * @example
+ * **Real-world evaluator usage:**
+ * ```typescript
+ * // Your data structure
+ * const example = {
+ *   question: "What is AI?",
+ *   context: "AI is artificial intelligence...",
+ *   answer: "AI stands for artificial intelligence",
+ * };
+ *
+ * // Evaluator expects: { input, reference, output }
+ * const mapping: ObjectMapping<typeof example> = {
+ *   input: "question",
+ *   reference: "context",
+ *   output: "answer",
+ * };
+ *
+ * const remapped = remapObject(example, mapping);
+ * // Now remapped has: { question, context, answer, input, reference, output }
+ * // The evaluator can access input, reference, and output fields
+ * ```
+ */
+export declare function remapObject<DataType extends Record<string, unknown>>(data: DataType, mapping: ObjectMapping<DataType>): DataType;
+//# sourceMappingURL=objectMappingUtils.d.ts.map

package/dist/esm/utils/objectMappingUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectMappingUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/objectMappingUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAe,MAAM,eAAe,CAAC;AAI3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkKG;AACH,wBAAgB,WAAW,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClE,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAC,GAC/B,QAAQ,CAUV"}

package/dist/esm/utils/objectMappingUtils.js

@@ -0,0 +1,191 @@
+import { JSONPath } from "jsonpath-plus";
+/**
+ * Remaps an object by applying field mappings while preserving original data.
+ *
+ * This function takes your original data object and a mapping configuration,
+ * then returns a new object that contains:
+ * - All original fields from the input data
+ * - Additional/overridden fields based on the mapping
+ *
+ * The mapping allows you to extract values using:
+ * - Simple property names: `"fieldName"`
+ * - Dot notation: `"user.profile.name"`
+ * - Array access: `"items[0].id"`
+ * - JSONPath expressions: `"$.items[*].id"`
+ * - Function extractors: `(data) => data.customField`
+ *
+ * @param data - The input data object to remap
+ * @param mapping - The mapping configuration defining how to extract/transform values
+ * @returns A new object with original fields plus mapped fields
+ *
+ * @example
+ * **Basic remapping:**
+ * ```typescript
+ * const data = {
+ *   name: "John",
+ *   age: 30,
+ *   email: "john@example.com",
+ * };
+ *
+ * const mapping: ObjectMapping<typeof data> = {
+ *   userName: "name",
+ *   userAge: "age",
+ * };
+ *
+ * const result = remapObject(data, mapping);
+ * // Result: {
+ * //   name: "John",
+ * //   age: 30,
+ * //   email: "john@example.com",
+ * //   userName: "John",      // Added from mapping
+ * //   userAge: 30,            // Added from mapping
+ * // }
+ * ```
+ *
+ * @example
+ * **Nested property extraction:**
+ * ```typescript
+ * const data = {
+ *   user: {
+ *     profile: {
+ *       firstName: "John",
+ *       lastName: "Doe",
+ *     },
+ *     email: "john@example.com",
+ *   },
+ * };
+ *
+ * const mapping: ObjectMapping<typeof data> = {
+ *   firstName: "user.profile.firstName",
+ *   lastName: "user.profile.lastName",
+ *   email: "user.email",
+ * };
+ *
+ * const result = remapObject(data, mapping);
+ * // Result includes original data plus:
+ * // {
+ * //   firstName: "John",
+ * //   lastName: "Doe",
+ * //   email: "john@example.com",
+ * // }
+ * ```
+ *
+ * @example
+ * **Array element access:**
+ * ```typescript
+ * const data = {
+ *   items: [
+ *     { id: 1, name: "Apple" },
+ *     { id: 2, name: "Banana" },
+ *   ],
+ * };
+ *
+ * const mapping: ObjectMapping<typeof data> = {
+ *   firstItemId: "items[0].id",
+ *   firstItemName: "items[0].name",
+ * };
+ *
+ * const result = remapObject(data, mapping);
+ * // Result includes:
+ * // {
+ * //   firstItemId: 1,
+ * //   firstItemName: "Apple",
+ * // }
+ * ```
+ *
+ * @example
+ * **Function-based transformation:**
+ * ```typescript
+ * const data = {
+ *   firstName: "John",
+ *   lastName: "Doe",
+ *   scores: [85, 92, 78],
+ * };
+ *
+ * const mapping: ObjectMapping<typeof data> = {
+ *   fullName: (data) => `${data.firstName} ${data.lastName}`,
+ *   averageScore: (data) =>
+ *     data.scores.reduce((a, b) => a + b, 0) / data.scores.length,
+ * };
+ *
+ * const result = remapObject(data, mapping);
+ * // Result includes:
+ * // {
+ * //   fullName: "John Doe",
+ * //   averageScore: 85,
+ * // }
+ * ```
+ *
+ * @example
+ * **Field override:**
+ * ```typescript
+ * const data = {
+ *   name: "John",
+ *   status: "inactive",
+ * };
+ *
+ * const mapping: ObjectMapping<typeof data> = {
+ *   // Override existing field
+ *   status: (data) => data.name === "John" ? "active" : "inactive",
+ *   // Add new field
+ *   displayName: (data) => `User: ${data.name}`,
+ * };
+ *
+ * const result = remapObject(data, mapping);
+ * // Result:
+ * // {
+ * //   name: "John",
+ * //   status: "active",        // Overridden
+ * //   displayName: "User: John", // Added
+ * // }
+ * ```
+ *
+ * @example
+ * **Real-world evaluator usage:**
+ * ```typescript
+ * // Your data structure
+ * const example = {
+ *   question: "What is AI?",
+ *   context: "AI is artificial intelligence...",
+ *   answer: "AI stands for artificial intelligence",
+ * };
+ *
+ * // Evaluator expects: { input, reference, output }
+ * const mapping: ObjectMapping<typeof example> = {
+ *   input: "question",
+ *   reference: "context",
+ *   output: "answer",
+ * };
+ *
+ * const remapped = remapObject(example, mapping);
+ * // Now remapped has: { question, context, answer, input, reference, output }
+ * // The evaluator can access input, reference, and output fields
+ * ```
+ */
+export function remapObject(data, mapping) {
+    return {
+        ...data,
+        ...Object.fromEntries(Object.entries(mapping).map(([key, value]) => [
+            key,
+            getMappedObjectValue(data, value),
+        ])),
+    };
+}
+/**
+ * Extracts a value from a data object using a value getter.
+ *
+ * This internal function handles the actual extraction logic, supporting both
+ * string-based paths (including JSONPath) and function-based extractors.
+ *
+ * @param data - The data object to extract from
+ * @param valueGetter - The value getter (string path or function)
+ * @returns The extracted value
+ *
+ * @internal
+ */
+function getMappedObjectValue(data, valueGetter) {
+    return typeof valueGetter === "function"
+        ? valueGetter(data)
+        : JSONPath({ path: valueGetter, json: data, wrap: false });
+}
+//# sourceMappingURL=objectMappingUtils.js.map

package/dist/esm/utils/objectMappingUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectMappingUtils.js","sourceRoot":"","sources":["../../../src/utils/objectMappingUtils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkKG;AACH,MAAM,UAAU,WAAW,CACzB,IAAc,EACd,OAAgC;IAEhC,OAAO;QACL,GAAG,IAAI;QACP,GAAG,MAAM,CAAC,WAAW,CACnB,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC;YAC5C,GAAG;YACH,oBAAoB,CAAC,IAAI,EAAE,KAAK,CAAC;SAClC,CAAC,CACH;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAS,oBAAoB,CAC3B,IAAc,EACd,WAAkC;IAElC,OAAO,OAAO,WAAW,KAAK,UAAU;QACtC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC;QACnB,CAAC,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;AAC/D,CAAC"}

package/dist/src/core/EvaluatorBase.d.ts

@@ -0,0 +1,19 @@
+import { CreateEvaluatorArgs, EvaluationKind, EvaluationResult, EvaluatorInterface, OptimizationDirection, TelemetryConfig } from "../types";
+import { ObjectMapping } from "../types/data";
+/**
+ * Base class for all evaluators
+ */
+export declare abstract class EvaluatorBase<RecordType extends Record<string, unknown>> implements EvaluatorInterface<RecordType> {
+    readonly name: string;
+    readonly kind: EvaluationKind;
+    readonly optimizationDirection?: OptimizationDirection;
+    readonly inputMapping?: ObjectMapping<RecordType>;
+    readonly telemetry?: TelemetryConfig;
+    constructor({ name, kind, optimizationDirection, inputMapping, telemetry, }: CreateEvaluatorArgs<RecordType>);
+    abstract evaluate(_example: RecordType): Promise<EvaluationResult>;
+    /**
+     * Binds the input mapping to the evaluator. It makes a a copy of the evaluator and returns it.
+     */
+    abstract bindInputMapping(inputMapping: ObjectMapping<RecordType>): EvaluatorBase<RecordType>;
+}
+//# sourceMappingURL=EvaluatorBase.d.ts.map

package/dist/src/core/EvaluatorBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EvaluatorBase.d.ts","sourceRoot":"","sources":["../../../src/core/EvaluatorBase.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,qBAAqB,EACrB,eAAe,EAChB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9C;;GAEG;AACH,8BAAsB,aAAa,CAAC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAC5E,YAAW,kBAAkB,CAAC,UAAU,CAAC;IAEzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,qBAAqB,CAAC,EAAE,qBAAqB,CAAC;IACvD,QAAQ,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;IAClD,QAAQ,CAAC,SAAS,CAAC,EAAE,eAAe,CAAC;gBACzB,EACV,IAAI,EACJ,IAAI,EACJ,qBAAqB,EACrB,YAAY,EACZ,SAAS,GACV,EAAE,mBAAmB,CAAC,UAAU,CAAC;IAOlC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAElE;;OAEG;IACH,QAAQ,CAAC,gBAAgB,CACvB,YAAY,EAAE,aAAa,CAAC,UAAU,CAAC,GACtC,aAAa,CAAC,UAAU,CAAC;CAC7B"}

package/dist/src/core/EvaluatorBase.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluatorBase = void 0;
+/**
+ * Base class for all evaluators
+ */
+class EvaluatorBase {
+    constructor({ name, kind, optimizationDirection, inputMapping, telemetry, }) {
+        this.name = name;
+        this.kind = kind;
+        this.optimizationDirection = optimizationDirection;
+        this.inputMapping = inputMapping;
+        this.telemetry = telemetry;
+    }
+}
+exports.EvaluatorBase = EvaluatorBase;
+//# sourceMappingURL=EvaluatorBase.js.map

package/dist/src/core/EvaluatorBase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EvaluatorBase.js","sourceRoot":"","sources":["../../../src/core/EvaluatorBase.ts"],"names":[],"mappings":";;;AAUA;;GAEG;AACH,MAAsB,aAAa;IAQjC,YAAY,EACV,IAAI,EACJ,IAAI,EACJ,qBAAqB,EACrB,YAAY,EACZ,SAAS,GACuB;QAChC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,qBAAqB,GAAG,qBAAqB,CAAC;QACnD,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;CASF;AA7BD,sCA6BC"}

package/dist/src/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./llm";
 export * from "./template";
 export * from "./types";
+export * from "./utils";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}

package/dist/src/index.js

@@ -17,4 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./llm"), exports);
 __exportStar(require("./template"), exports);
 __exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
 //# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wCAAsB;AACtB,6CAA2B;AAC3B,0CAAwB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wCAAsB;AACtB,6CAA2B;AAC3B,0CAAwB;AACxB,0CAAwB"}

package/dist/src/llm/ClassificationEvaluator.d.ts

@@ -1,17 +1,34 @@
-import { CreateClassificationEvaluatorArgs, EvaluatorFn, Template, WithPromptTemplate } from "../types";
+import { ClassificationChoicesMap, CreateClassificationEvaluatorArgs, EvaluatorFn, PromptTemplate, WithPromptTemplate } from "../types";
+import { ObjectMapping } from "../types/data";
 import { LLMEvaluator } from "./LLMEvaluator";
+import { LanguageModel } from "ai";
 /**
  * An LLM evaluator that performs evaluation via classification
  */
 export declare class ClassificationEvaluator<RecordType extends Record<string, unknown>> extends LLMEvaluator<RecordType> implements WithPromptTemplate {
     readonly evaluatorFn: EvaluatorFn<RecordType>;
-    readonly promptTemplate: Template;
+    readonly promptTemplate: PromptTemplate;
+    /**
+     * A dynamically computed set of prompt template variables
+     */
     private _promptTemplateVariables;
-    constructor(args: CreateClassificationEvaluatorArgs);
+    /**
+     * The model to use for classification
+     */
+    readonly model: LanguageModel;
+    /**
+     * The choices to classify the example into
+     */
+    readonly choices: ClassificationChoicesMap;
+    constructor(args: CreateClassificationEvaluatorArgs<RecordType>);
     evaluate: (example: RecordType) => Promise<import("../types").EvaluationResult>;
     /**
      * List out the prompt template variables needed to perform evaluation
      */
     get promptTemplateVariables(): string[];
+    /**
+     * Binds the input mapping to the evaluator. It makes a a copy of the evaluator and returns it.
+     */
+    bindInputMapping(inputMapping: ObjectMapping<RecordType>): ClassificationEvaluator<RecordType>;
 }
 //# sourceMappingURL=ClassificationEvaluator.d.ts.map

package/dist/src/llm/ClassificationEvaluator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClassificationEvaluator.d.ts","sourceRoot":"","sources":["../../../src/llm/ClassificationEvaluator.ts"],"names":[],"mappings":"AACA,OAAO,EACL,iCAAiC,EACjC,WAAW,EACX,QAAQ,EACR,kBAAkB,EACnB,MAAM,UAAU,CAAC;AAGlB,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;GAEG;AACH,qBAAa,uBAAuB,CAAC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAC7E,SAAQ,YAAY,CAAC,UAAU,CAC/B,YAAW,kBAAkB;IAE7B,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC;IAC9C,QAAQ,CAAC,cAAc,EAAE,QAAQ,CAAC;IAClC,OAAO,CAAC,wBAAwB,CAAuB;gBAC3C,IAAI,EAAE,iCAAiC;IAKnD,QAAQ,GAAI,SAAS,UAAU,kDAE7B;IACF;;OAEG;IACH,IAAI,uBAAuB,IAAI,MAAM,EAAE,CAStC;CACF"}
+{"version":3,"file":"ClassificationEvaluator.d.ts","sourceRoot":"","sources":["../../../src/llm/ClassificationEvaluator.ts"],"names":[],"mappings":"AACA,OAAO,EACL,wBAAwB,EACxB,iCAAiC,EACjC,WAAW,EACX,cAAc,EACd,kBAAkB,EACnB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAI9C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AAEnC;;GAEG;AACH,qBAAa,uBAAuB,CAAC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAC7E,SAAQ,YAAY,CAAC,UAAU,CAC/B,YAAW,kBAAkB;IAE7B,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC;IAC9C,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;IACxC;;OAEG;IACH,OAAO,CAAC,wBAAwB,CAAuB;IACvD;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,wBAAwB,CAAC;gBAE/B,IAAI,EAAE,iCAAiC,CAAC,UAAU,CAAC;IAS/D,QAAQ,GAAI,SAAS,UAAU,kDAM7B;IACF;;OAEG;IACH,IAAI,uBAAuB,IAAI,MAAM,EAAE,CAStC;IACD;;OAEG;IACH,gBAAgB,CACd,YAAY,EAAE,aAAa,CAAC,UAAU,CAAC,GACtC,uBAAuB,CAAC,UAAU,CAAC;CAMvC"}