@arizeai/phoenix-evals 0.6.0 → 0.6.2

package/dist/esm/__generated__/default_templates/DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.d.ts

@@ -0,0 +1,3 @@
+import type { ClassificationEvaluatorConfig } from "../types.js";
+export declare const DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG: ClassificationEvaluatorConfig;
+//# sourceMappingURL=DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.d.ts.map

package/dist/esm/__generated__/default_templates/DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.d.ts","sourceRoot":"","sources":["../../../../src/__generated__/default_templates/DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,UAAU,CAAC;AAE9D,eAAO,MAAM,kDAAkD,EAAE,6BAkChE,CAAC"}

package/dist/esm/__generated__/default_templates/DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.js

@@ -0,0 +1,37 @@
+// This file is generated. Do not edit by hand.
+export const DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG = {
+    name: "document_relevance",
+    description: "A specialized evaluator for determining document relevance to a given question.",
+    optimizationDirection: "MAXIMIZE",
+    template: [
+        {
+            role: "user",
+            content: `
+You are comparing a document to a question and trying to determine
+if the document text contains information relevant to answering the
+question. Here is the data:
+
+[BEGIN DATA]
+************
+[Question]: {{input}}
+************
+[Document text]: {{documentText}}
+************
+[END DATA]
+
+Compare the question above to the document text. You must determine
+whether the document text contains information that can answer the
+question. Please focus on whether the very specific question can be
+answered by the information in the document text. Your response must be
+either "relevant" or "unrelated". "unrelated" means that the document
+text does not contain an answer to the question. "relevant" means the
+document text contains an answer to the question.
+`,
+        },
+    ],
+    choices: {
+        "relevant": 1,
+        "unrelated": 0
+    },
+};
+//# sourceMappingURL=DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.js.map

package/dist/esm/__generated__/default_templates/DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.js","sourceRoot":"","sources":["../../../../src/__generated__/default_templates/DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAI/C,MAAM,CAAC,MAAM,kDAAkD,GAAkC;IAC/F,IAAI,EAAE,oBAAoB;IAC1B,WAAW,EAAE,iFAAiF;IAC9F,qBAAqB,EAAE,UAAU;IACjC,QAAQ,EAAE;QACR;YACE,IAAI,EAAE,MAAM;YACZ,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;CAoBd;SACI;KACF;IACD,OAAO,EAAE;QACT,UAAU,EAAE,CAAC;QACb,WAAW,EAAE,CAAC;KACf;CACA,CAAC"}

package/dist/esm/__generated__/default_templates/HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.d.ts

@@ -0,0 +1,3 @@
+import type { ClassificationEvaluatorConfig } from "../types.js";
+export declare const HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG: ClassificationEvaluatorConfig;
+//# sourceMappingURL=HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.d.ts.map

package/dist/esm/__generated__/default_templates/HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.d.ts","sourceRoot":"","sources":["../../../../src/__generated__/default_templates/HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,UAAU,CAAC;AAE9D,eAAO,MAAM,6CAA6C,EAAE,6BAwC3D,CAAC"}

package/dist/esm/__generated__/default_templates/HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.js

@@ -0,0 +1,43 @@
+// This file is generated. Do not edit by hand.
+export const HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG = {
+    name: "hallucination",
+    description: "A specialized evaluator for detecting hallucinations in grounded LLM responses.",
+    optimizationDirection: "MINIMIZE",
+    template: [
+        {
+            role: "user",
+            content: `
+In this task, you will be presented with a query, some context and a response. The response
+is generated to the question based on the context. The response may contain false
+information. You must use the context to determine if the response to the question
+contains false information, if the response is a hallucination of facts. Your objective is
+to determine whether the response text contains factual information and is not a
+hallucination. A 'hallucination' refers to a response that is not based on the context or
+assumes information that is not available in the context. Your response should be a single
+word: either 'factual' or 'hallucinated', and it should not include any other text or
+characters. 'hallucinated' indicates that the response provides factually inaccurate
+information to the query based on the context. 'factual' indicates that the response to
+the question is correct relative to the context, and does not contain made up
+information. Please read the query and context carefully before determining your
+response.
+
+[BEGIN DATA]
+************
+[Query]: {{input}}
+************
+[Context]: {{context}}
+************
+[Response]: {{output}}
+************
+[END DATA]
+
+Is the response above factual or hallucinated based on the query and context?
+`,
+        },
+    ],
+    choices: {
+        "hallucinated": 1,
+        "factual": 0
+    },
+};
+//# sourceMappingURL=HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.js.map

package/dist/esm/__generated__/default_templates/HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.js","sourceRoot":"","sources":["../../../../src/__generated__/default_templates/HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAI/C,MAAM,CAAC,MAAM,6CAA6C,GAAkC;IAC1F,IAAI,EAAE,eAAe;IACrB,WAAW,EAAE,iFAAiF;IAC9F,qBAAqB,EAAE,UAAU;IACjC,QAAQ,EAAE;QACR;YACE,IAAI,EAAE,MAAM;YACZ,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Bd;SACI;KACF;IACD,OAAO,EAAE;QACT,cAAc,EAAE,CAAC;QACjB,SAAS,EAAE,CAAC;KACb;CACA,CAAC"}

package/dist/esm/__generated__/default_templates/index.d.ts

@@ -0,0 +1,3 @@
+export { DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG } from "./DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.js";
+export { HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG } from "./HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/__generated__/default_templates/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/__generated__/default_templates/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kDAAkD,EAAE,MAAM,sDAAsD,CAAC;AAC1H,OAAO,EAAE,6CAA6C,EAAE,MAAM,iDAAiD,CAAC"}

package/dist/esm/__generated__/default_templates/index.js

@@ -0,0 +1,4 @@
+// This file is generated. Do not edit by hand.
+export { DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG } from "./DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.js";
+export { HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG } from "./HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/__generated__/default_templates/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/__generated__/default_templates/index.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAE/C,OAAO,EAAE,kDAAkD,EAAE,MAAM,sDAAsD,CAAC;AAC1H,OAAO,EAAE,6CAA6C,EAAE,MAAM,iDAAiD,CAAC"}

package/dist/esm/__generated__/types.d.ts

@@ -0,0 +1,9 @@
+import type { PromptTemplate } from "../types/templating.js";
+export type ClassificationEvaluatorConfig = {
+    name: string;
+    description: string;
+    optimizationDirection: "MINIMIZE" | "MAXIMIZE";
+    template: PromptTemplate;
+    choices: Record<string, number>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/__generated__/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/__generated__/types.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,MAAM,MAAM,6BAA6B,GAAG;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,qBAAqB,EAAE,UAAU,GAAG,UAAU,CAAC;IAC/C,QAAQ,EAAE,cAAc,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC,CAAC"}

package/dist/esm/__generated__/types.js

@@ -0,0 +1,3 @@
+// This file is generated. Do not edit by hand.
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/__generated__/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/__generated__/types.ts"],"names":[],"mappings":"AAAA,+CAA+C"}

package/dist/esm/core/FunctionEvaluator.d.ts

@@ -0,0 +1,16 @@
+import { CreateEvaluatorArgs, EvaluationResult, ObjectMapping } from "../types/index.js";
+import { EvaluatorBase } from "./EvaluatorBase.js";
+type FunctionEvaluatorArgs<RecordType extends Record<string, unknown>> = CreateEvaluatorArgs<RecordType> & {
+    evaluateFn: (args: RecordType) => Promise<EvaluationResult>;
+};
+/**
+ * A class that constructs an evaluator based on an evaluate function.
+ */
+export declare class FunctionEvaluator<RecordType extends Record<string, unknown>> extends EvaluatorBase<RecordType> {
+    readonly evaluateFn: (args: RecordType) => Promise<EvaluationResult>;
+    constructor({ evaluateFn, ...args }: FunctionEvaluatorArgs<RecordType>);
+    evaluate(args: RecordType): Promise<EvaluationResult>;
+    bindInputMapping(inputMapping: ObjectMapping<RecordType>): FunctionEvaluator<RecordType>;
+}
+export {};
+//# sourceMappingURL=FunctionEvaluator.d.ts.map

package/dist/esm/core/FunctionEvaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionEvaluator.d.ts","sourceRoot":"","sources":["../../../src/core/FunctionEvaluator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEhF,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,KAAK,qBAAqB,CAAC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACnE,mBAAmB,CAAC,UAAU,CAAC,GAAG;IAChC,UAAU,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAC7D,CAAC;AACJ;;GAEG;AACH,qBAAa,iBAAiB,CAC5B,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAC1C,SAAQ,aAAa,CAAC,UAAU,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;gBACzD,EAAE,UAAU,EAAE,GAAG,IAAI,EAAE,EAAE,qBAAqB,CAAC,UAAU,CAAC;IAIhE,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAG3D,gBAAgB,CACd,YAAY,EAAE,aAAa,CAAC,UAAU,CAAC,GACtC,iBAAiB,CAAC,UAAU,CAAC;CAGjC"}

package/dist/esm/core/FunctionEvaluator.js

@@ -0,0 +1,18 @@
+import { EvaluatorBase } from "./EvaluatorBase.js";
+/**
+ * A class that constructs an evaluator based on an evaluate function.
+ */
+export class FunctionEvaluator extends EvaluatorBase {
+    evaluateFn;
+    constructor({ evaluateFn, ...args }) {
+        super({ ...args });
+        this.evaluateFn = evaluateFn;
+    }
+    async evaluate(args) {
+        return this.evaluateFn(args);
+    }
+    bindInputMapping(inputMapping) {
+        return new FunctionEvaluator({ ...this, inputMapping });
+    }
+}
+//# sourceMappingURL=FunctionEvaluator.js.map

package/dist/esm/core/FunctionEvaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionEvaluator.js","sourceRoot":"","sources":["../../../src/core/FunctionEvaluator.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAMhD;;GAEG;AACH,MAAM,OAAO,iBAEX,SAAQ,aAAyB;IACxB,UAAU,CAAkD;IACrE,YAAY,EAAE,UAAU,EAAE,GAAG,IAAI,EAAqC;QACpE,KAAK,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC;QACnB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IAC/B,CAAC;IACD,KAAK,CAAC,QAAQ,CAAC,IAAgB;QAC7B,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IACD,gBAAgB,CACd,YAAuC;QAEvC,OAAO,IAAI,iBAAiB,CAAC,EAAE,GAAG,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC;IAC1D,CAAC;CACF"}

package/dist/esm/helpers/asEvaluatorFn.d.ts

@@ -0,0 +1,6 @@
+import { AnyFn, EvaluatorFn } from "../types/index.js";
+/**
+ * A function that converts a generic function into an evaluator function
+ */
+export declare function asEvaluatorFn<RecordType extends Record<string, unknown>>(fn: AnyFn): EvaluatorFn<RecordType>;
+//# sourceMappingURL=asEvaluatorFn.d.ts.map

package/dist/esm/helpers/asEvaluatorFn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asEvaluatorFn.d.ts","sourceRoot":"","sources":["../../../src/helpers/asEvaluatorFn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAK9C;;GAEG;AACH,wBAAgB,aAAa,CAAC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACtE,EAAE,EAAE,KAAK,GACR,WAAW,CAAC,UAAU,CAAC,CAQzB"}

package/dist/esm/helpers/asEvaluatorFn.js

@@ -0,0 +1,15 @@
+import { isPromise } from "../utils/typeUtils.js";
+import { toEvaluationResult } from "./toEvaluationResult.js";
+/**
+ * A function that converts a generic function into an evaluator function
+ */
+export function asEvaluatorFn(fn) {
+    return async (...args) => {
+        let result = fn(...args);
+        if (isPromise(result)) {
+            result = await result;
+        }
+        return toEvaluationResult(result);
+    };
+}
+//# sourceMappingURL=asEvaluatorFn.js.map

package/dist/esm/helpers/asEvaluatorFn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"asEvaluatorFn.js","sourceRoot":"","sources":["../../../src/helpers/asEvaluatorFn.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D;;GAEG;AACH,MAAM,UAAU,aAAa,CAC3B,EAAS;IAET,OAAO,KAAK,EAAE,GAAG,IAAI,EAAE,EAAE;QACvB,IAAI,MAAM,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;QACzB,IAAI,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;YACtB,MAAM,GAAG,MAAM,MAAM,CAAC;QACxB,CAAC;QACD,OAAO,kBAAkB,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC,CAAC;AACJ,CAAC"}

package/dist/esm/helpers/createEvaluator.d.ts

@@ -0,0 +1,141 @@
+import { EvaluatorBase } from "../core/EvaluatorBase.js";
+import { EvaluationKind, OptimizationDirection, TelemetryConfig } from "../types/index.js";
+type AnyFn = (...args: any[]) => any;
+/**
+ * Options for creating a custom evaluator using {@link CreateEvaluator}.
+ *
+ * @public
+ */
+export type CreateEvaluatorOptions = {
+    /**
+     * The name of the evaluator / metric that it measures.
+     *
+     * If not provided, the function will attempt to infer the name from the function's `name` property.
+     * If the function has no name, a unique name will be generated.
+     *
+     * @example
+     * ```typescript
+     * const evaluator = CreateEvaluator(myFunction, { name: "custom-metric" });
+     * ```
+     */
+    name?: string;
+    /**
+     * The kind of the evaluation.
+     *
+     * - `"CODE"`: Code-based evaluator that runs custom logic
+     * - `"LLM"`: LLM-based evaluator that uses a language model
+     *
+     * @defaultValue `"CODE"`
+     *
+     * @example
+     * ```typescript
+     * const evaluator = CreateEvaluator(myFunction, { kind: "CODE" });
+     * ```
+     */
+    kind?: EvaluationKind;
+    /**
+     * The direction to optimize the numeric evaluation score.
+     *
+     * - `"MAXIMIZE"`: Higher scores are better (e.g., accuracy, F1 score)
+     * - `"MINIMIZE"`: Lower scores are better (e.g., error rate, latency)
+     *
+     * @defaultValue `"MAXIMIZE"`
+     *
+     * @example
+     * ```typescript
+     * const evaluator = CreateEvaluator(myFunction, {
+     *   optimizationDirection: "MAXIMIZE"
+     * });
+     * ```
+     */
+    optimizationDirection?: OptimizationDirection;
+    /**
+     * The telemetry configuration for the evaluator.
+     *
+     * When enabled, the evaluator will automatically create OpenTelemetry spans
+     * for tracing and observability. This allows you to track evaluator performance
+     * and debug issues in distributed systems.
+     *
+     * @defaultValue `{ isEnabled: true }`
+     *
+     * @example
+     * ```typescript
+     * const evaluator = CreateEvaluator(myFunction, {
+     *   telemetry: { isEnabled: true, tracer: myTracer }
+     * });
+     * ```
+     */
+    telemetry?: TelemetryConfig;
+};
+/**
+ * A factory function for creating a custom evaluator from any function.
+ *
+ * This function wraps a user-provided function into an evaluator that can be used
+ * with Phoenix experiments and evaluations. The function can be synchronous or
+ * asynchronous, and can return a number, an {@link EvaluationResult} object, or
+ * a value that will be automatically converted to an evaluation result.
+ *
+ * The evaluator will automatically:
+ * - Convert the function's return value to an {@link EvaluationResult}
+ * - Handle both sync and async functions
+ * - Wrap the function with OpenTelemetry spans if telemetry is enabled
+ * - Infer the evaluator name from the function name if not provided
+ *
+ * @typeParam RecordType - The type of the input record that the evaluator expects.
+ *   Must extend `Record<string, unknown>`.
+ * @typeParam Fn - The type of the function being wrapped. Must be a function that
+ *   accepts the record type and returns a value compatible with {@link EvaluationResult}.
+ *
+ * @param fn - The function to wrap as an evaluator. Can be synchronous or asynchronous.
+ *   The function should accept a record of type `RecordType` and return either:
+ *   - A number (will be converted to `{ score: number }`)
+ *   - An {@link EvaluationResult} object
+ *   - Any value that can be converted to an evaluation result
+ *
+ * @param options - Optional configuration for the evaluator. See {@link CreateEvaluatorOptions}
+ *   for details on available options.
+ *
+ * @returns An {@link EvaluatorInterface} that can be used with Phoenix experiments
+ *   and evaluation workflows.
+ *
+ * @example
+ * Basic usage with a simple scoring function:
+ * ```typescript
+ * const accuracyEvaluator = CreateEvaluator(
+ *   ({ output, expected }) => {
+ *     return output === expected ? 1 : 0;
+ *   },
+ *   {
+ *     name: "accuracy",
+ *     kind: "CODE",
+ *     optimizationDirection: "MAXIMIZE"
+ *   }
+ * );
+ *
+ * const result = await accuracyEvaluator.evaluate({
+ *   output: "correct answer",
+ *   expected: "correct answer"
+ * });
+ * // result: { score: 1 }
+ * ```
+ *
+ *
+ * @example
+ * Returning a full EvaluationResult:
+ * ```typescript
+ * const qualityEvaluator = CreateEvaluator(
+ *   ({ output }) => {
+ *     const score = calculateQuality(output);
+ *     return {
+ *       score,
+ *       label: score > 0.8 ? "high" : "low",
+ *       explanation: `Quality score: ${score}`
+ *     };
+ *   },
+ *   { name: "quality" }
+ * );
+ * ```
+ */
+export declare function createEvaluator<RecordType extends Record<string, unknown> = Record<string, unknown>, Fn extends AnyFn = AnyFn>(fn: Fn, options?: CreateEvaluatorOptions): EvaluatorBase<RecordType>;
+export {};
+//# sourceMappingURL=createEvaluator.d.ts.map

package/dist/esm/helpers/createEvaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createEvaluator.d.ts","sourceRoot":"","sources":["../../../src/helpers/createEvaluator.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,eAAe,EAChB,MAAM,UAAU,CAAC;AAKlB,KAAK,KAAK,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;AAMrC;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC;;;;;;;;;;OAUG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;;;;;;;;OAYG;IACH,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB;;;;;;;;;;;;;;OAcG;IACH,qBAAqB,CAAC,EAAE,qBAAqB,CAAC;IAC9C;;;;;;;;;;;;;;;OAeG;IACH,SAAS,CAAC,EAAE,eAAe,CAAC;CAC7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,wBAAgB,eAAe,CAC7B,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpE,EAAE,SAAS,KAAK,GAAG,KAAK,EACxB,EAAE,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,sBAAsB,GAAG,aAAa,CAAC,UAAU,CAAC,CAyBrE"}

package/dist/esm/helpers/createEvaluator.js

@@ -0,0 +1,96 @@
+import { withSpan } from "@arizeai/openinference-core";
+import { FunctionEvaluator } from "../core/FunctionEvaluator.js";
+import { asEvaluatorFn } from "./asEvaluatorFn.js";
+function generateUniqueName() {
+    return `evaluator-${Math.random().toString(36).substring(2, 15)}`;
+}
+/**
+ * A factory function for creating a custom evaluator from any function.
+ *
+ * This function wraps a user-provided function into an evaluator that can be used
+ * with Phoenix experiments and evaluations. The function can be synchronous or
+ * asynchronous, and can return a number, an {@link EvaluationResult} object, or
+ * a value that will be automatically converted to an evaluation result.
+ *
+ * The evaluator will automatically:
+ * - Convert the function's return value to an {@link EvaluationResult}
+ * - Handle both sync and async functions
+ * - Wrap the function with OpenTelemetry spans if telemetry is enabled
+ * - Infer the evaluator name from the function name if not provided
+ *
+ * @typeParam RecordType - The type of the input record that the evaluator expects.
+ *   Must extend `Record<string, unknown>`.
+ * @typeParam Fn - The type of the function being wrapped. Must be a function that
+ *   accepts the record type and returns a value compatible with {@link EvaluationResult}.
+ *
+ * @param fn - The function to wrap as an evaluator. Can be synchronous or asynchronous.
+ *   The function should accept a record of type `RecordType` and return either:
+ *   - A number (will be converted to `{ score: number }`)
+ *   - An {@link EvaluationResult} object
+ *   - Any value that can be converted to an evaluation result
+ *
+ * @param options - Optional configuration for the evaluator. See {@link CreateEvaluatorOptions}
+ *   for details on available options.
+ *
+ * @returns An {@link EvaluatorInterface} that can be used with Phoenix experiments
+ *   and evaluation workflows.
+ *
+ * @example
+ * Basic usage with a simple scoring function:
+ * ```typescript
+ * const accuracyEvaluator = CreateEvaluator(
+ *   ({ output, expected }) => {
+ *     return output === expected ? 1 : 0;
+ *   },
+ *   {
+ *     name: "accuracy",
+ *     kind: "CODE",
+ *     optimizationDirection: "MAXIMIZE"
+ *   }
+ * );
+ *
+ * const result = await accuracyEvaluator.evaluate({
+ *   output: "correct answer",
+ *   expected: "correct answer"
+ * });
+ * // result: { score: 1 }
+ * ```
+ *
+ *
+ * @example
+ * Returning a full EvaluationResult:
+ * ```typescript
+ * const qualityEvaluator = CreateEvaluator(
+ *   ({ output }) => {
+ *     const score = calculateQuality(output);
+ *     return {
+ *       score,
+ *       label: score > 0.8 ? "high" : "low",
+ *       explanation: `Quality score: ${score}`
+ *     };
+ *   },
+ *   { name: "quality" }
+ * );
+ * ```
+ */
+export function createEvaluator(fn, options) {
+    const { name, kind, optimizationDirection, telemetry = { isEnabled: true }, } = options || {};
+    const evaluatorName = name || fn.name || generateUniqueName();
+    let evaluateFn = asEvaluatorFn(fn);
+    // Add OpenTelemetry span wrapping if telemetry is enabled
+    if (telemetry && telemetry.isEnabled) {
+        evaluateFn = withSpan(evaluateFn, {
+            tracer: telemetry.tracer,
+            name: evaluatorName,
+            kind: "EVALUATOR",
+        });
+    }
+    return new FunctionEvaluator({
+        evaluateFn,
+        name: evaluatorName,
+        kind: kind || "CODE",
+        optimizationDirection: optimizationDirection || "MAXIMIZE",
+        telemetry,
+    });
+}
+//# sourceMappingURL=createEvaluator.js.map

package/dist/esm/helpers/createEvaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createEvaluator.js","sourceRoot":"","sources":["../../../src/helpers/createEvaluator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAGvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAO9D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAKhD,SAAS,kBAAkB;IACzB,OAAO,aAAa,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;AACpE,CAAC;AAqED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,MAAM,UAAU,eAAe,CAG7B,EAAM,EAAE,OAAgC;IACxC,MAAM,EACJ,IAAI,EACJ,IAAI,EACJ,qBAAqB,EACrB,SAAS,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,GAChC,GAAG,OAAO,IAAI,EAAE,CAAC;IAClB,MAAM,aAAa,GAAG,IAAI,IAAI,EAAE,CAAC,IAAI,IAAI,kBAAkB,EAAE,CAAC;IAC9D,IAAI,UAAU,GAAG,aAAa,CAAa,EAAE,CAAC,CAAC;IAE/C,0DAA0D;IAC1D,IAAI,SAAS,IAAI,SAAS,CAAC,SAAS,EAAE,CAAC;QACrC,UAAU,GAAG,QAAQ,CAAC,UAAU,EAAE;YAChC,MAAM,EAAE,SAAS,CAAC,MAAM;YACxB,IAAI,EAAE,aAAa;YACnB,IAAI,EAAE,WAAW;SAClB,CAAC,CAAC;IACL,CAAC;IACD,OAAO,IAAI,iBAAiB,CAAa;QACvC,UAAU;QACV,IAAI,EAAE,aAAa;QACnB,IAAI,EAAE,IAAI,IAAI,MAAM;QACpB,qBAAqB,EAAE,qBAAqB,IAAI,UAAU;QAC1D,SAAS;KACV,CAAC,CAAC;AACL,CAAC"}

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

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

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

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

package/dist/esm/helpers/index.js

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

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

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

package/dist/esm/helpers/toEvaluationResult.d.ts

@@ -0,0 +1,67 @@
+import { EvaluationResult } from "../types/index.js";
+/**
+ * Converts an unknown value to an {@link EvaluationResult}.
+ *
+ * This function provides a flexible way to normalize various return types from
+ * evaluator functions into a standardized `EvaluationResult` format. It handles
+ * multiple input types:
+ *
+ * - **Numbers**: Converted to `{ score: number }`
+ * - **Strings**: Converted to `{ label: string }`
+ * - **Objects**: Extracts `score`, `label`, and `explanation` properties if present
+ * - **Other types**: Returns an empty `EvaluationResult` object
+ *
+ * This is particularly useful when creating evaluators from functions that may
+ * return different types, ensuring consistent evaluation result formatting.
+ *
+ * @param result - The value to convert to an EvaluationResult. Can be:
+ *   - A number (converted to score)
+ *   - A string (converted to label)
+ *   - An object with optional `score`, `label`, and/or `explanation` properties
+ *   - Any other value (returns empty object)
+ *
+ * @returns An {@link EvaluationResult} object with extracted properties
+ *
+ * @example
+ * Convert a number to an EvaluationResult:
+ * ```typescript
+ * const result = toEvaluationResult(0.95);
+ * // Returns: { score: 0.95 }
+ * ```
+ *
+ * @example
+ * Convert a string to an EvaluationResult:
+ * ```typescript
+ * const result = toEvaluationResult("correct");
+ * // Returns: { label: "correct" }
+ * ```
+ *
+ * @example
+ * Convert an object with all properties:
+ * ```typescript
+ * const result = toEvaluationResult({
+ *   score: 0.9,
+ *   label: "high",
+ *   explanation: "High quality output"
+ * });
+ * // Returns: { score: 0.9, label: "high", explanation: "High quality output" }
+ * ```
+ *
+ * @example
+ * Convert an object with partial properties:
+ * ```typescript
+ * const result = toEvaluationResult({ score: 0.8 });
+ * // Returns: { score: 0.8 }
+ * ```
+ *
+ * @example
+ * Handle null or undefined:
+ * ```typescript
+ * const result = toEvaluationResult(null);
+ * // Returns: {}
+ * ```
+ *
+ * @public
+ */
+export declare function toEvaluationResult(result: unknown): EvaluationResult;
+//# sourceMappingURL=toEvaluationResult.d.ts.map

package/dist/esm/helpers/toEvaluationResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toEvaluationResult.d.ts","sourceRoot":"","sources":["../../../src/helpers/toEvaluationResult.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAuD5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAyBpE"}