@arizeai/phoenix-evals 0.6.0 → 0.6.2

package/src/__generated__/default_templates/DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.ts

@@ -0,0 +1,39 @@
+// This file is generated. Do not edit by hand.
+
+import type { ClassificationEvaluatorConfig } from "../types";
+
+export const DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG: ClassificationEvaluatorConfig = {
+  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
+},
+};

package/src/__generated__/default_templates/HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.ts

@@ -0,0 +1,45 @@
+// This file is generated. Do not edit by hand.
+
+import type { ClassificationEvaluatorConfig } from "../types";
+
+export const HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG: ClassificationEvaluatorConfig = {
+  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
+},
+};

package/src/__generated__/default_templates/index.ts

@@ -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";
+export { HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG } from "./HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG";

package/src/__generated__/types.ts

@@ -0,0 +1,11 @@
+// This file is generated. Do not edit by hand.
+
+import type { PromptTemplate } from "../types/templating";
+
+export type ClassificationEvaluatorConfig = {
+  name: string;
+  description: string;
+  optimizationDirection: "MINIMIZE" | "MAXIMIZE";
+  template: PromptTemplate;
+  choices: Record<string, number>;
+};

package/src/core/FunctionEvaluator.ts

@@ -0,0 +1,28 @@
+import { CreateEvaluatorArgs, EvaluationResult, ObjectMapping } from "../types";
+
+import { EvaluatorBase } from "./EvaluatorBase";
+
+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 class FunctionEvaluator<
+  RecordType extends Record<string, unknown>,
+> extends EvaluatorBase<RecordType> {
+  readonly evaluateFn: (args: RecordType) => Promise<EvaluationResult>;
+  constructor({ evaluateFn, ...args }: FunctionEvaluatorArgs<RecordType>) {
+    super({ ...args });
+    this.evaluateFn = evaluateFn;
+  }
+  async evaluate(args: RecordType): Promise<EvaluationResult> {
+    return this.evaluateFn(args);
+  }
+  bindInputMapping(
+    inputMapping: ObjectMapping<RecordType>
+  ): FunctionEvaluator<RecordType> {
+    return new FunctionEvaluator({ ...this, inputMapping });
+  }
+}

package/src/helpers/asEvaluatorFn.ts

@@ -0,0 +1,19 @@
+import { AnyFn, EvaluatorFn } from "../types";
+import { isPromise } from "../utils/typeUtils";
+
+import { toEvaluationResult } from "./toEvaluationResult";
+
+/**
+ * A function that converts a generic function into an evaluator function
+ */
+export function asEvaluatorFn<RecordType extends Record<string, unknown>>(
+  fn: AnyFn
+): EvaluatorFn<RecordType> {
+  return async (...args) => {
+    let result = fn(...args);
+    if (isPromise(result)) {
+      result = await result;
+    }
+    return toEvaluationResult(result);
+  };
+}

package/src/helpers/createEvaluator.ts

@@ -0,0 +1,184 @@
+import { withSpan } from "@arizeai/openinference-core";
+
+import { EvaluatorBase } from "../core/EvaluatorBase";
+import { FunctionEvaluator } from "../core/FunctionEvaluator";
+import {
+  EvaluationKind,
+  OptimizationDirection,
+  TelemetryConfig,
+} from "../types";
+
+import { asEvaluatorFn } from "./asEvaluatorFn";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyFn = (...args: any[]) => any;
+
+function generateUniqueName(): string {
+  return `evaluator-${Math.random().toString(36).substring(2, 15)}`;
+}
+
+/**
+ * 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 function createEvaluator<
+  RecordType extends Record<string, unknown> = Record<string, unknown>,
+  Fn extends AnyFn = AnyFn,
+>(fn: Fn, options?: CreateEvaluatorOptions): EvaluatorBase<RecordType> {
+  const {
+    name,
+    kind,
+    optimizationDirection,
+    telemetry = { isEnabled: true },
+  } = options || {};
+  const evaluatorName = name || fn.name || generateUniqueName();
+  let evaluateFn = asEvaluatorFn<RecordType>(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<RecordType>({
+    evaluateFn,
+    name: evaluatorName,
+    kind: kind || "CODE",
+    optimizationDirection: optimizationDirection || "MAXIMIZE",
+    telemetry,
+  });
+}

package/src/helpers/index.ts

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

package/src/helpers/toEvaluationResult.ts

@@ -0,0 +1,145 @@
+import { EvaluationResult } from "../types";
+
+/**
+ * Type guard to check if a value has a score property.
+ *
+ * @param result - The value to check
+ * @returns True if the value is an object with a numeric score property
+ *
+ * @internal
+ */
+function resultHasScore(result: unknown): result is { score: number } {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    "score" in result &&
+    typeof result.score === "number"
+  );
+}
+
+/**
+ * Type guard to check if a value has a label property.
+ *
+ * @param result - The value to check
+ * @returns True if the value is an object with a string label property
+ *
+ * @internal
+ */
+function resultHasLabel(result: unknown): result is { label: string } {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    "label" in result &&
+    typeof result.label === "string"
+  );
+}
+
+/**
+ * Type guard to check if a value has an explanation property.
+ *
+ * @param result - The value to check
+ * @returns True if the value is an object with a string explanation property
+ *
+ * @internal
+ */
+function resultHasExplanation(
+  result: unknown
+): result is { explanation: string } {
+  return (
+    typeof result === "object" &&
+    result !== null &&
+    "explanation" in result &&
+    typeof result.explanation === "string"
+  );
+}
+
+/**
+ * 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 function toEvaluationResult(result: unknown): EvaluationResult {
+  if (typeof result === "number") {
+    return {
+      score: result,
+    };
+  }
+  if (typeof result === "string") {
+    return {
+      label: result,
+    };
+  }
+  if (typeof result === "object" && result !== null) {
+    const evaluationResult: EvaluationResult = {};
+    if (resultHasScore(result)) {
+      evaluationResult.score = result.score;
+    }
+    if (resultHasLabel(result)) {
+      evaluationResult.label = result.label;
+    }
+    if (resultHasExplanation(result)) {
+      evaluationResult.explanation = result.explanation;
+    }
+    return evaluationResult;
+  }
+  return {};
+}

package/src/index.ts

@@ -2,3 +2,4 @@ export * from "./llm";
 export * from "./template";
 export * from "./types";
 export * from "./utils";
+export * from "./helpers";

package/src/llm/{createDocumentRelevancyEvaluator.ts → createDocumentRelevanceEvaluator.ts}

@@ -1,17 +1,14 @@
-import {
-  DOCUMENT_RELEVANCY_CHOICES,
-  DOCUMENT_RELEVANCY_TEMPLATE,
-} from "../default_templates/DOCUMENT_RELEVANCY_TEMPLATE";
+import { DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG } from "../__generated__/default_templates";
 import { CreateClassificationEvaluatorArgs } from "../types/evals";
 
 import { ClassificationEvaluator } from "./ClassificationEvaluator";
 import { createClassificationEvaluator } from "./createClassificationEvaluator";
 
-export interface DocumentRelevancyEvaluatorArgs<
+export interface DocumentRelevanceEvaluatorArgs<
   RecordType extends Record<
     string,
     unknown
-  > = DocumentRelevancyEvaluationRecord,
+  > = DocumentRelevanceEvaluationRecord,
 > extends Omit<
     CreateClassificationEvaluatorArgs<RecordType>,
     "promptTemplate" | "choices" | "optimizationDirection" | "name"
@@ -23,33 +20,33 @@ export interface DocumentRelevancyEvaluatorArgs<
 }
 
 /**
- * A record to be evaluated by the document relevancy evaluator.
+ * A record to be evaluated by the document relevance evaluator.
  */
-export interface DocumentRelevancyEvaluationRecord {
+export interface DocumentRelevanceEvaluationRecord {
   input: string;
   documentText: string;
   [key: string]: unknown;
 }
 
 /**
- * Creates a document relevancy evaluator function.
+ * Creates a document relevance 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 - The arguments for creating the document relevance 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.choices - The possible classification choices (defaults to DOCUMENT_RELEVANCE_CHOICES).
+ * @param args.promptTemplate - The prompt template to use (defaults to DOCUMENT_RELEVANCE_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
+ * @returns An evaluator function that takes a {@link DocumentRelevanceExample} 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 evaluator = createDocumentRelevanceEvaluator({ 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.",
@@ -57,19 +54,19 @@ export interface DocumentRelevancyEvaluationRecord {
  * console.log(result.label); // "relevant" or "unrelated"
  * ```
  */
-export function createDocumentRelevancyEvaluator<
+export function createDocumentRelevanceEvaluator<
   RecordType extends Record<
     string,
     unknown
-  > = DocumentRelevancyEvaluationRecord,
+  > = DocumentRelevanceEvaluationRecord,
 >(
-  args: DocumentRelevancyEvaluatorArgs<RecordType>
+  args: DocumentRelevanceEvaluatorArgs<RecordType>
 ): ClassificationEvaluator<RecordType> {
   const {
-    choices = DOCUMENT_RELEVANCY_CHOICES,
-    promptTemplate = DOCUMENT_RELEVANCY_TEMPLATE,
-    optimizationDirection = "MAXIMIZE",
-    name = "document_relevancy",
+    choices = DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.choices,
+    promptTemplate = DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.template,
+    optimizationDirection = DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.optimizationDirection,
+    name = DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.name,
     ...rest
   } = args;
   return createClassificationEvaluator<RecordType>({

package/src/llm/createHallucinationEvaluator.ts

@@ -1,7 +1,4 @@
-import {
-  HALLUCINATION_CHOICES,
-  HALLUCINATION_TEMPLATE,
-} from "../default_templates/HALLUCINATION_TEMPLATE";
+import { HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG } from "../__generated__/default_templates";
 import { CreateClassificationEvaluatorArgs } from "../types/evals";
 
 import { ClassificationEvaluator } from "./ClassificationEvaluator";
@@ -25,7 +22,6 @@ export interface HallucinationEvaluatorArgs<
 export type HallucinationEvaluationRecord = {
   input: string;
   output: string;
-  reference?: string;
   context?: string;
 };
 /**
@@ -40,10 +36,10 @@ export function createHallucinationEvaluator<
   args: HallucinationEvaluatorArgs<RecordType>
 ): ClassificationEvaluator<RecordType> {
   const {
-    choices = HALLUCINATION_CHOICES,
-    promptTemplate = HALLUCINATION_TEMPLATE,
-    optimizationDirection = "MINIMIZE",
-    name = "hallucination",
+    choices = HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.choices,
+    promptTemplate = HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.template,
+    optimizationDirection = HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.optimizationDirection,
+    name = HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.name,
     ...rest
   } = args;
   return createClassificationEvaluator<RecordType>({

package/src/llm/index.ts

@@ -2,6 +2,6 @@ export * from "./generateClassification";
 export * from "./createClassifierFn";
 export * from "./createClassificationEvaluator";
 export * from "./createHallucinationEvaluator";
-export * from "./createDocumentRelevancyEvaluator";
+export * from "./createDocumentRelevanceEvaluator";
 export * from "./ClassificationEvaluator";
 export * from "./LLMEvaluator";

package/src/types/base.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AnyFn = (...args: any[]) => any;

package/src/types/index.ts

@@ -2,3 +2,4 @@ export * from "./evals";
 export * from "./templating";
 export * from "./otel";
 export * from "./data";
+export * from "./base";

package/src/utils/bindEvaluator.ts

@@ -206,7 +206,7 @@ export type BindingContext<RecordType extends Record<string, unknown>> = {
  *
  * // Document relevancy evaluator (if it exists)
  * const relevancyEvaluator = bindEvaluator<EvaluationData>(
- *   createDocumentRelevancyEvaluator({ model: openai("gpt-4") }),
+ *   createDocumentRelevanceEvaluator({ model: openai("gpt-4") }),
  *   {
  *     inputMapping: {
  *       query: "userQuery",

package/src/utils/typeUtils.ts

@@ -0,0 +1,14 @@
+/**
+ * Type guard for if a function is a Promise
+ * @param value
+ * @returns true if it is a Promise
+ */
+export function isPromise<T = unknown>(value: unknown): value is Promise<T> {
+  return (
+    !!value &&
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    typeof (value as any)?.then === "function" &&
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    typeof (value as any)?.catch === "function"
+  );
+}

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"}