@arizeai/phoenix-evals 0.5.1 → 0.6.1

package/src/utils/bindEvaluator.ts

@@ -0,0 +1,229 @@
+import { EvaluatorBase } from "../core/EvaluatorBase";
+import { ObjectMapping } from "../types/data";
+
+/**
+ * Context for binding an evaluator with input mapping configuration.
+ *
+ * This type defines the structure for binding an evaluator to a specific data shape
+ * by mapping the evaluator's expected input fields to the actual data structure.
+ *
+ * @example
+ * ```typescript
+ * // Map evaluator fields to your data structure
+ * const context: BindingContext<MyDataType> = {
+ *   inputMapping: {
+ *     input: "userQuery",        // Maps "input" to "userQuery" field
+ *     reference: "context",      // Maps "reference" to "context" field
+ *     output: "modelResponse",   // Maps "output" to "modelResponse" field
+ *   },
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using nested property access
+ * const context: BindingContext<ApiResponse> = {
+ *   inputMapping: {
+ *     input: "request.body.query",
+ *     reference: "request.body.context",
+ *     output: "response.data.text",
+ *   },
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using function-based mapping for transformations
+ * const context: BindingContext<RawData> = {
+ *   inputMapping: {
+ *     input: "question",
+ *     reference: (data) => data.context.join("\n"),  // Transform array to string
+ *     output: "answer",
+ *   },
+ * };
+ * ```
+ *
+ * @typeParam RecordType - The type of the data record that will be evaluated
+ */
+export type BindingContext<RecordType extends Record<string, unknown>> = {
+  /**
+   * Mapping of evaluator input fields to data source fields.
+   *
+   * The keys represent the field names expected by the evaluator (e.g., "input", "output", "reference"),
+   * and the values specify how to extract those fields from your data structure.
+   *
+   * Supports:
+   * - Simple property names: `"fieldName"`
+   * - Dot notation: `"user.profile.name"`
+   * - Array access: `"items[0].id"`
+   * - JSONPath expressions: `"$.items[*].id"`
+   * - Function extractors: `(data) => data.customField.toUpperCase()`
+   */
+  inputMapping: ObjectMapping<RecordType>;
+};
+
+/**
+ * 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>(
+ *   createDocumentRelevanceEvaluator({ model: openai("gpt-4") }),
+ *   {
+ *     inputMapping: {
+ *       query: "userQuery",
+ *       document: "systemContext",
+ *       output: "modelOutput",
+ *     },
+ *   }
+ * );
+ * ```
+ */
+export function bindEvaluator<RecordType extends Record<string, unknown>>(
+  evaluator: EvaluatorBase<RecordType>,
+  context: BindingContext<RecordType>
+): EvaluatorBase<RecordType> {
+  let boundEvaluator: EvaluatorBase<RecordType> = evaluator;
+  if (context.inputMapping) {
+    boundEvaluator = boundEvaluator.bindInputMapping(context.inputMapping);
+  }
+  return boundEvaluator;
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from "./bindEvaluator";

package/src/utils/objectMappingUtils.ts

@@ -0,0 +1,202 @@
+import { ObjectMapping, ValueGetter } from "../types/data";
+
+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<DataType extends Record<string, unknown>>(
+  data: DataType,
+  mapping: ObjectMapping<DataType>
+): DataType {
+  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<DataType extends Record<string, unknown>>(
+  data: DataType,
+  valueGetter: ValueGetter<DataType>
+): DataType[keyof DataType] {
+  return typeof valueGetter === "function"
+    ? valueGetter(data)
+    : JSONPath({ path: valueGetter, json: data, wrap: false });
+}

package/dist/esm/default_templates/DOCUMENT_RELEVANCY_TEMPLATE.d.ts

@@ -1,6 +0,0 @@
-export declare const DOCUMENT_RELEVANCY_TEMPLATE = "\nYou are comparing a document to a question and trying to determine if the document text\ncontains information relevant to answering the question. Here is the data:\n\n    [BEGIN DATA]\n    ************\n    [Question]: {{input}}\n    ************\n    [Document text]: {{documentText}}\n    ************\n    [END DATA]\n\nCompare the Question above to the Document text. You must determine whether the Document text\ncontains information that can answer the Question. Please focus on whether the very specific\nquestion can be answered by the information in the Document text.\nYour response must be single word, either \"relevant\" or \"unrelated\",\nand should not contain any text or characters aside from that word.\n\"unrelated\" means that the document text does not contain an answer to the Question.\n\"relevant\" means the document text contains an answer to the Question.\n";
-export declare const DOCUMENT_RELEVANCY_CHOICES: {
-    relevant: number;
-    unrelated: number;
-};
-//# sourceMappingURL=DOCUMENT_RELEVANCY_TEMPLATE.d.ts.map

package/dist/esm/default_templates/DOCUMENT_RELEVANCY_TEMPLATE.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DOCUMENT_RELEVANCY_TEMPLATE.d.ts","sourceRoot":"","sources":["../../../src/default_templates/DOCUMENT_RELEVANCY_TEMPLATE.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,23BAmBvC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;CAGtC,CAAC"}

package/dist/esm/default_templates/DOCUMENT_RELEVANCY_TEMPLATE.js

@@ -1,25 +0,0 @@
-export const DOCUMENT_RELEVANCY_TEMPLATE = `
-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 single word, either "relevant" or "unrelated",
-and should not contain any text or characters aside from that word.
-"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.
-`;
-export const DOCUMENT_RELEVANCY_CHOICES = {
-    relevant: 1,
-    unrelated: 0,
-};
-//# sourceMappingURL=DOCUMENT_RELEVANCY_TEMPLATE.js.map

package/dist/esm/default_templates/DOCUMENT_RELEVANCY_TEMPLATE.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DOCUMENT_RELEVANCY_TEMPLATE.js","sourceRoot":"","sources":["../../../src/default_templates/DOCUMENT_RELEVANCY_TEMPLATE.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,2BAA2B,GAAG;;;;;;;;;;;;;;;;;;;CAmB1C,CAAC;AAEF,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACxC,QAAQ,EAAE,CAAC;IACX,SAAS,EAAE,CAAC;CACb,CAAC"}

package/dist/esm/default_templates/HALLUCINATION_TEMPLATE.d.ts

@@ -1,6 +0,0 @@
-export declare const HALLUCINATION_TEMPLATE = "\nIn this task, you will be presented with a query, a reference text and an answer. The answer is\ngenerated to the question based on the reference text. The answer may contain false information. You\nmust use the reference text to determine if the answer to the question contains false information,\nif the answer is a hallucination of facts. Your objective is to determine whether the answer text\ncontains factual information and is not a hallucination. A 'hallucination' refers to\nan answer that is not based on the reference text or assumes information that is not available in\nthe reference text. Your response should be a single word: either \"factual\" or \"hallucinated\", and\nit should not include any other text or characters. \"hallucinated\" indicates that the answer\nprovides factually inaccurate information to the query based on the reference text. \"factual\"\nindicates that the answer to the question is correct relative to the reference text, and does not\ncontain made up information. Please read the query and reference text carefully before determining\nyour response.\n\n    [BEGIN DATA]\n    ************\n    [Query]: {{input}}\n    ************\n    [Reference text]: {{reference}}\n    ************\n    [Answer]: {{output}}\n    ************\n    [END DATA]\n\nIs the answer above factual or hallucinated based on the query and reference text?\n";
-export declare const HALLUCINATION_CHOICES: {
-    hallucinated: number;
-    factual: number;
-};
-//# sourceMappingURL=HALLUCINATION_TEMPLATE.d.ts.map

package/dist/esm/default_templates/HALLUCINATION_TEMPLATE.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HALLUCINATION_TEMPLATE.d.ts","sourceRoot":"","sources":["../../../src/default_templates/HALLUCINATION_TEMPLATE.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,u2CAyBlC,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;CAGjC,CAAC"}

package/dist/esm/default_templates/HALLUCINATION_TEMPLATE.js

@@ -1,31 +0,0 @@
-export const HALLUCINATION_TEMPLATE = `
-In this task, you will be presented with a query, a reference text and an answer. The answer is
-generated to the question based on the reference text. The answer may contain false information. You
-must use the reference text to determine if the answer to the question contains false information,
-if the answer is a hallucination of facts. Your objective is to determine whether the answer text
-contains factual information and is not a hallucination. A 'hallucination' refers to
-an answer that is not based on the reference text or assumes information that is not available in
-the reference text. 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 answer
-provides factually inaccurate information to the query based on the reference text. "factual"
-indicates that the answer to the question is correct relative to the reference text, and does not
-contain made up information. Please read the query and reference text carefully before determining
-your response.
-
-    [BEGIN DATA]
-    ************
-    [Query]: {{input}}
-    ************
-    [Reference text]: {{reference}}
-    ************
-    [Answer]: {{output}}
-    ************
-    [END DATA]
-
-Is the answer above factual or hallucinated based on the query and reference text?
-`;
-export const HALLUCINATION_CHOICES = {
-    hallucinated: 1,
-    factual: 0,
-};
-//# sourceMappingURL=HALLUCINATION_TEMPLATE.js.map

package/dist/esm/default_templates/HALLUCINATION_TEMPLATE.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"HALLUCINATION_TEMPLATE.js","sourceRoot":"","sources":["../../../src/default_templates/HALLUCINATION_TEMPLATE.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;CAyBrC,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,YAAY,EAAE,CAAC;IACf,OAAO,EAAE,CAAC;CACX,CAAC"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/default_templates/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,+BAA+B,CAAC"}

package/dist/esm/default_templates/index.js

@@ -1,3 +0,0 @@
-export * from "./HALLUCINATION_TEMPLATE.js";
-export * from "./DOCUMENT_RELEVANCY_TEMPLATE.js";
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/default_templates/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,+BAA+B,CAAC"}

package/dist/esm/llm/createDocumentRelevancyEvaluator.d.ts

@@ -1,43 +0,0 @@
-import { CreateClassificationEvaluatorArgs, Evaluator } from "../types/evals.js";
-export interface DocumentRelevancyEvaluatorArgs extends Omit<CreateClassificationEvaluatorArgs, "promptTemplate" | "choices" | "optimizationDirection" | "name"> {
-    optimizationDirection?: CreateClassificationEvaluatorArgs["optimizationDirection"];
-    name?: CreateClassificationEvaluatorArgs["name"];
-    choices?: CreateClassificationEvaluatorArgs["choices"];
-    promptTemplate?: CreateClassificationEvaluatorArgs["promptTemplate"];
-}
-/**
- * A record to be evaluated by the document relevancy evaluator.
- */
-export interface DocumentRelevancyEvaluationRecord {
-    input: string;
-    documentText: string;
-    [key: string]: unknown;
-}
-/**
- * Creates a document relevancy evaluator function.
- *
- * This function returns an evaluator that determines whether a given document text
- * is relevant to a provided input question. The evaluator uses a classification model
- * and a prompt template to make its determination.
- *
- * @param args - The arguments for creating the document relevancy evaluator.
- * @param args.model - The model to use for classification.
- * @param args.choices - The possible classification choices (defaults to DOCUMENT_RELEVANCY_CHOICES).
- * @param args.promptTemplate - The prompt template to use (defaults to DOCUMENT_RELEVANCY_TEMPLATE).
- * @param args.telemetry - The telemetry to use for the evaluator.
- *
- * @returns An evaluator function that takes a {@link DocumentRelevancyExample} and returns a classification result
- * indicating whether the document is relevant to the input question.
- *
- * @example
- * ```ts
- * const evaluator = createDocumentRelevancyEvaluator({ model: openai("gpt-4o-mini") });
- * const result = await evaluator.evaluate({
- *   input: "What is the capital of France?",
- *   documentText: "Paris is the capital and most populous city of France.",
- * });
- * console.log(result.label); // "relevant" or "unrelated"
- * ```
- */
-export declare function createDocumentRelevancyEvaluator<RecordType extends Record<string, unknown> = DocumentRelevancyEvaluationRecord>(args: DocumentRelevancyEvaluatorArgs): Evaluator<RecordType>;
-//# sourceMappingURL=createDocumentRelevancyEvaluator.d.ts.map

package/dist/esm/llm/createDocumentRelevancyEvaluator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createDocumentRelevancyEvaluator.d.ts","sourceRoot":"","sources":["../../../src/llm/createDocumentRelevancyEvaluator.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,iCAAiC,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAI9E,MAAM,WAAW,8BACf,SAAQ,IAAI,CACV,iCAAiC,EACjC,gBAAgB,GAAG,SAAS,GAAG,uBAAuB,GAAG,MAAM,CAChE;IACD,qBAAqB,CAAC,EAAE,iCAAiC,CAAC,uBAAuB,CAAC,CAAC;IACnF,IAAI,CAAC,EAAE,iCAAiC,CAAC,MAAM,CAAC,CAAC;IACjD,OAAO,CAAC,EAAE,iCAAiC,CAAC,SAAS,CAAC,CAAC;IACvD,cAAc,CAAC,EAAE,iCAAiC,CAAC,gBAAgB,CAAC,CAAC;CACtE;AAED;;GAEG;AACH,MAAM,WAAW,iCAAiC;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,gCAAgC,CAC9C,UAAU,SAAS,MAAM,CACvB,MAAM,EACN,OAAO,CACR,GAAG,iCAAiC,EACrC,IAAI,EAAE,8BAA8B,GAAG,SAAS,CAAC,UAAU,CAAC,CAiB7D"}

package/dist/esm/llm/createDocumentRelevancyEvaluator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createDocumentRelevancyEvaluator.js","sourceRoot":"","sources":["../../../src/llm/createDocumentRelevancyEvaluator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,0BAA0B,EAC1B,2BAA2B,GAC5B,MAAM,kDAAkD,CAAC;AAG1D,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAsBhF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,gCAAgC,CAK9C,IAAoC;IACpC,MAAM,EACJ,OAAO,GAAG,0BAA0B,EACpC,cAAc,GAAG,2BAA2B,EAC5C,qBAAqB,GAAG,UAAU,EAClC,IAAI,GAAG,oBAAoB,EAC3B,GAAG,IAAI,EACR,GAAG,IAAI,CAAC;IAET,OAAO,6BAA6B,CAAa;QAC/C,GAAG,IAAI;QACP,cAAc;QACd,OAAO;QACP,qBAAqB;QACrB,IAAI;QACJ,GAAG,IAAI;KACR,CAAC,CAAC;AACL,CAAC"}

package/dist/src/default_templates/DOCUMENT_RELEVANCY_TEMPLATE.d.ts

@@ -1,6 +0,0 @@
-export declare const DOCUMENT_RELEVANCY_TEMPLATE = "\nYou are comparing a document to a question and trying to determine if the document text\ncontains information relevant to answering the question. Here is the data:\n\n    [BEGIN DATA]\n    ************\n    [Question]: {{input}}\n    ************\n    [Document text]: {{documentText}}\n    ************\n    [END DATA]\n\nCompare the Question above to the Document text. You must determine whether the Document text\ncontains information that can answer the Question. Please focus on whether the very specific\nquestion can be answered by the information in the Document text.\nYour response must be single word, either \"relevant\" or \"unrelated\",\nand should not contain any text or characters aside from that word.\n\"unrelated\" means that the document text does not contain an answer to the Question.\n\"relevant\" means the document text contains an answer to the Question.\n";
-export declare const DOCUMENT_RELEVANCY_CHOICES: {
-    relevant: number;
-    unrelated: number;
-};
-//# sourceMappingURL=DOCUMENT_RELEVANCY_TEMPLATE.d.ts.map

package/dist/src/default_templates/DOCUMENT_RELEVANCY_TEMPLATE.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DOCUMENT_RELEVANCY_TEMPLATE.d.ts","sourceRoot":"","sources":["../../../src/default_templates/DOCUMENT_RELEVANCY_TEMPLATE.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,23BAmBvC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;CAGtC,CAAC"}

package/dist/src/default_templates/DOCUMENT_RELEVANCY_TEMPLATE.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DOCUMENT_RELEVANCY_CHOICES = exports.DOCUMENT_RELEVANCY_TEMPLATE = void 0;
-exports.DOCUMENT_RELEVANCY_TEMPLATE = `
-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 single word, either "relevant" or "unrelated",
-and should not contain any text or characters aside from that word.
-"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.
-`;
-exports.DOCUMENT_RELEVANCY_CHOICES = {
-    relevant: 1,
-    unrelated: 0,
-};
-//# sourceMappingURL=DOCUMENT_RELEVANCY_TEMPLATE.js.map

package/dist/src/default_templates/DOCUMENT_RELEVANCY_TEMPLATE.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DOCUMENT_RELEVANCY_TEMPLATE.js","sourceRoot":"","sources":["../../../src/default_templates/DOCUMENT_RELEVANCY_TEMPLATE.ts"],"names":[],"mappings":";;;AAAa,QAAA,2BAA2B,GAAG;;;;;;;;;;;;;;;;;;;CAmB1C,CAAC;AAEW,QAAA,0BAA0B,GAAG;IACxC,QAAQ,EAAE,CAAC;IACX,SAAS,EAAE,CAAC;CACb,CAAC"}

package/dist/src/default_templates/HALLUCINATION_TEMPLATE.d.ts

@@ -1,6 +0,0 @@
-export declare const HALLUCINATION_TEMPLATE = "\nIn this task, you will be presented with a query, a reference text and an answer. The answer is\ngenerated to the question based on the reference text. The answer may contain false information. You\nmust use the reference text to determine if the answer to the question contains false information,\nif the answer is a hallucination of facts. Your objective is to determine whether the answer text\ncontains factual information and is not a hallucination. A 'hallucination' refers to\nan answer that is not based on the reference text or assumes information that is not available in\nthe reference text. Your response should be a single word: either \"factual\" or \"hallucinated\", and\nit should not include any other text or characters. \"hallucinated\" indicates that the answer\nprovides factually inaccurate information to the query based on the reference text. \"factual\"\nindicates that the answer to the question is correct relative to the reference text, and does not\ncontain made up information. Please read the query and reference text carefully before determining\nyour response.\n\n    [BEGIN DATA]\n    ************\n    [Query]: {{input}}\n    ************\n    [Reference text]: {{reference}}\n    ************\n    [Answer]: {{output}}\n    ************\n    [END DATA]\n\nIs the answer above factual or hallucinated based on the query and reference text?\n";
-export declare const HALLUCINATION_CHOICES: {
-    hallucinated: number;
-    factual: number;
-};
-//# sourceMappingURL=HALLUCINATION_TEMPLATE.d.ts.map

package/dist/src/default_templates/HALLUCINATION_TEMPLATE.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HALLUCINATION_TEMPLATE.d.ts","sourceRoot":"","sources":["../../../src/default_templates/HALLUCINATION_TEMPLATE.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,u2CAyBlC,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;CAGjC,CAAC"}