langchain 0.0.147 → 0.0.148

package/dist/evaluation/criteria/prompt.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROMPT_WITH_REFERENCES = exports.CRITERIA_PROMPT = void 0;
+const index_js_1 = require("../../prompts/index.cjs");
+const template = `You are assessing a submitted answer on a given task or input based on a set of criteria. Here is the data:
+[BEGIN DATA]
+***
+[Input]: {input}
+***
+[Submission]: {output}
+***
+[Criteria]: {criteria}
+***
+[END DATA]
+Does the submission meet the Criteria? First, write out in a step by step manner your reasoning about each criterion to be sure that your conclusion is correct. Avoid simply stating the correct answers at the outset. Then print only the single character "Y" or "N" (without quotes or punctuation) on its own line corresponding to the correct answer of whether the submission meets all criteria. At the end, repeat just the letter again by itself on a new line.`;
+exports.CRITERIA_PROMPT = new index_js_1.PromptTemplate({
+    inputVariables: ["input", "output", "criteria"],
+    template,
+});
+const referenceTemplate = `You are assessing a submitted answer on a given task or input based on a set of criteria. Here is the data:
+[BEGIN DATA]
+***
+[Input]: {input}
+***
+[Submission]: {output}
+***
+[Criteria]: {criteria}
+***
+[Reference]: {reference}
+***
+[END DATA]
+Does the submission meet the Criteria? First, write out in a step by step manner your reasoning about each criterion to be sure that your conclusion is correct. Avoid simply stating the correct answers at the outset. Then print only the single character "Y" or "N" (without quotes or punctuation) on its own line corresponding to the correct answer of whether the submission meets all criteria. At the end, repeat just the letter again by itself on a new line.`;
+exports.PROMPT_WITH_REFERENCES = new index_js_1.PromptTemplate({
+    inputVariables: ["input", "output", "criteria", "reference"],
+    template: referenceTemplate,
+});

package/dist/evaluation/criteria/prompt.d.ts

@@ -0,0 +1,12 @@
+import { PromptTemplate } from "../../prompts/index.js";
+export declare const CRITERIA_PROMPT: PromptTemplate<{
+    output: any;
+    input: any;
+    criteria: any;
+}, any>;
+export declare const PROMPT_WITH_REFERENCES: PromptTemplate<{
+    output: any;
+    input: any;
+    criteria: any;
+    reference: any;
+}, any>;

package/dist/evaluation/criteria/prompt.js

@@ -0,0 +1,33 @@
+import { PromptTemplate } from "../../prompts/index.js";
+const template = `You are assessing a submitted answer on a given task or input based on a set of criteria. Here is the data:
+[BEGIN DATA]
+***
+[Input]: {input}
+***
+[Submission]: {output}
+***
+[Criteria]: {criteria}
+***
+[END DATA]
+Does the submission meet the Criteria? First, write out in a step by step manner your reasoning about each criterion to be sure that your conclusion is correct. Avoid simply stating the correct answers at the outset. Then print only the single character "Y" or "N" (without quotes or punctuation) on its own line corresponding to the correct answer of whether the submission meets all criteria. At the end, repeat just the letter again by itself on a new line.`;
+export const CRITERIA_PROMPT = /* #__PURE__ */ new PromptTemplate({
+    inputVariables: ["input", "output", "criteria"],
+    template,
+});
+const referenceTemplate = `You are assessing a submitted answer on a given task or input based on a set of criteria. Here is the data:
+[BEGIN DATA]
+***
+[Input]: {input}
+***
+[Submission]: {output}
+***
+[Criteria]: {criteria}
+***
+[Reference]: {reference}
+***
+[END DATA]
+Does the submission meet the Criteria? First, write out in a step by step manner your reasoning about each criterion to be sure that your conclusion is correct. Avoid simply stating the correct answers at the outset. Then print only the single character "Y" or "N" (without quotes or punctuation) on its own line corresponding to the correct answer of whether the submission meets all criteria. At the end, repeat just the letter again by itself on a new line.`;
+export const PROMPT_WITH_REFERENCES = /* #__PURE__ */ new PromptTemplate({
+    inputVariables: ["input", "output", "criteria", "reference"],
+    template: referenceTemplate,
+});

package/dist/evaluation/embedding_distance/base.cjs

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PairwiseEmbeddingDistanceEvalChain = exports.EmbeddingDistanceEvalChain = exports.computeEvaluationScore = exports.getDistanceCalculationFunction = void 0;
+const ml_distance_1 = require("ml-distance");
+const base_js_1 = require("../base.cjs");
+const openai_js_1 = require("../../embeddings/openai.cjs");
+/**
+ * Get the distance function for the given distance type.
+ * @param distance The distance type.
+ * @return The distance function.
+ */
+function getDistanceCalculationFunction(distanceType) {
+    const distanceFunctions = {
+        cosine: (X, Y) => 1.0 - ml_distance_1.similarity.cosine(X, Y),
+        euclidean: ml_distance_1.distance.euclidean,
+        manhattan: ml_distance_1.distance.manhattan,
+        chebyshev: ml_distance_1.distance.chebyshev,
+    };
+    return distanceFunctions[distanceType];
+}
+exports.getDistanceCalculationFunction = getDistanceCalculationFunction;
+/**
+ * Compute the score based on the distance metric.
+ * @param vectors The input vectors.
+ * @param distanceMetric The distance metric.
+ * @return The computed score.
+ */
+function computeEvaluationScore(vectors, distanceMetric) {
+    const metricFunction = getDistanceCalculationFunction(distanceMetric);
+    return metricFunction(vectors[0], vectors[1]);
+}
+exports.computeEvaluationScore = computeEvaluationScore;
+/**
+ * Use embedding distances to score semantic difference between
+ * a prediction and reference.
+ */
+class EmbeddingDistanceEvalChain extends base_js_1.StringEvaluator {
+    constructor(fields) {
+        super();
+        Object.defineProperty(this, "requiresReference", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "requiresInput", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "outputKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "score"
+        });
+        Object.defineProperty(this, "embedding", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "distanceMetric", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "cosine"
+        });
+        this.embedding = fields?.embedding || new openai_js_1.OpenAIEmbeddings();
+        this.distanceMetric = fields?.distanceMetric || "cosine";
+    }
+    _chainType() {
+        return `embedding_${this.distanceMetric}_distance`;
+    }
+    async _evaluateStrings(args, config) {
+        const result = await this.call(args, config);
+        return { [this.outputKey]: result[this.outputKey] };
+    }
+    get inputKeys() {
+        return ["reference", "prediction"];
+    }
+    get outputKeys() {
+        return [this.outputKey];
+    }
+    async _call(values, _runManager) {
+        const { prediction, reference } = values;
+        if (!this.embedding)
+            throw new Error("Embedding is undefined");
+        const vectors = await this.embedding.embedDocuments([
+            prediction,
+            reference,
+        ]);
+        const score = computeEvaluationScore(vectors, this.distanceMetric);
+        return { [this.outputKey]: score };
+    }
+}
+exports.EmbeddingDistanceEvalChain = EmbeddingDistanceEvalChain;
+/**
+ * Use embedding distances to score semantic difference between two predictions.
+ */
+class PairwiseEmbeddingDistanceEvalChain extends base_js_1.PairwiseStringEvaluator {
+    constructor(fields) {
+        super();
+        Object.defineProperty(this, "requiresReference", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "requiresInput", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "outputKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "score"
+        });
+        Object.defineProperty(this, "embedding", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "distanceMetric", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "cosine"
+        });
+        this.embedding = fields?.embedding || new openai_js_1.OpenAIEmbeddings();
+        this.distanceMetric = fields?.distanceMetric || "cosine";
+    }
+    _chainType() {
+        return `pairwise_embedding_${this.distanceMetric}_distance`;
+    }
+    async _evaluateStringPairs(args, config) {
+        const result = await this.call(args, config);
+        return { [this.outputKey]: result[this.outputKey] };
+    }
+    get inputKeys() {
+        return ["prediction", "predictionB"];
+    }
+    get outputKeys() {
+        return [this.outputKey];
+    }
+    async _call(values, _runManager) {
+        const { prediction, predictionB } = values;
+        if (!this.embedding)
+            throw new Error("Embedding is undefined");
+        const vectors = await this.embedding.embedDocuments([
+            prediction,
+            predictionB,
+        ]);
+        const score = computeEvaluationScore(vectors, this.distanceMetric);
+        return { [this.outputKey]: score };
+    }
+}
+exports.PairwiseEmbeddingDistanceEvalChain = PairwiseEmbeddingDistanceEvalChain;

package/dist/evaluation/embedding_distance/base.d.ts

@@ -0,0 +1,78 @@
+import { PairwiseStringEvaluator, PairwiseStringEvaluatorArgs, StringEvaluator, StringEvaluatorArgs } from "../base.js";
+import { ChainValues } from "../../schema/index.js";
+import { CallbackManagerForChainRun, Callbacks } from "../../callbacks/index.js";
+import { BaseCallbackConfig } from "../../callbacks/manager.js";
+import { Embeddings } from "../../embeddings/base.js";
+/**
+ *
+ * Embedding Distance Metric.
+ *
+ * COSINE: Cosine distance metric.
+ * EUCLIDEAN: Euclidean distance metric.
+ * MANHATTAN: Manhattan distance metric.
+ * CHEBYSHEV: Chebyshev distance metric.
+ * HAMMING: Hamming distance metric.
+ */
+export type EmbeddingDistanceType = "cosine" | "euclidean" | "manhattan" | "chebyshev";
+/**
+ * Embedding Distance Evaluation Chain Input.
+ */
+export interface EmbeddingDistanceEvalChainInput {
+    /**
+     * The embedding objects to vectorize the outputs.
+     */
+    embedding?: Embeddings;
+    /**
+     * The distance metric to use
+     * for comparing the embeddings.
+     */
+    distanceMetric?: EmbeddingDistanceType;
+}
+type VectorFunction = (xVector: number[], yVector: number[]) => number;
+/**
+ * Get the distance function for the given distance type.
+ * @param distance The distance type.
+ * @return The distance function.
+ */
+export declare function getDistanceCalculationFunction(distanceType: EmbeddingDistanceType): VectorFunction;
+/**
+ * Compute the score based on the distance metric.
+ * @param vectors The input vectors.
+ * @param distanceMetric The distance metric.
+ * @return The computed score.
+ */
+export declare function computeEvaluationScore(vectors: number[][], distanceMetric: EmbeddingDistanceType): number;
+/**
+ * Use embedding distances to score semantic difference between
+ * a prediction and reference.
+ */
+export declare class EmbeddingDistanceEvalChain extends StringEvaluator implements EmbeddingDistanceEvalChainInput {
+    requiresReference: boolean;
+    requiresInput: boolean;
+    outputKey: string;
+    embedding?: Embeddings;
+    distanceMetric: EmbeddingDistanceType;
+    constructor(fields: EmbeddingDistanceEvalChainInput);
+    _chainType(): "embedding_cosine_distance" | "embedding_euclidean_distance" | "embedding_manhattan_distance" | "embedding_chebyshev_distance";
+    _evaluateStrings(args: StringEvaluatorArgs, config: Callbacks | BaseCallbackConfig | undefined): Promise<ChainValues>;
+    get inputKeys(): string[];
+    get outputKeys(): string[];
+    _call(values: ChainValues, _runManager: CallbackManagerForChainRun | undefined): Promise<ChainValues>;
+}
+/**
+ * Use embedding distances to score semantic difference between two predictions.
+ */
+export declare class PairwiseEmbeddingDistanceEvalChain extends PairwiseStringEvaluator implements EmbeddingDistanceEvalChainInput {
+    requiresReference: boolean;
+    requiresInput: boolean;
+    outputKey: string;
+    embedding?: Embeddings;
+    distanceMetric: EmbeddingDistanceType;
+    constructor(fields: EmbeddingDistanceEvalChainInput);
+    _chainType(): "pairwise_embedding_cosine_distance" | "pairwise_embedding_euclidean_distance" | "pairwise_embedding_manhattan_distance" | "pairwise_embedding_chebyshev_distance";
+    _evaluateStringPairs(args: PairwiseStringEvaluatorArgs, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;
+    get inputKeys(): string[];
+    get outputKeys(): string[];
+    _call(values: ChainValues, _runManager: CallbackManagerForChainRun | undefined): Promise<ChainValues>;
+}
+export {};

package/dist/evaluation/embedding_distance/base.js

@@ -0,0 +1,156 @@
+import { distance, similarity } from "ml-distance";
+import { PairwiseStringEvaluator, StringEvaluator, } from "../base.js";
+import { OpenAIEmbeddings } from "../../embeddings/openai.js";
+/**
+ * Get the distance function for the given distance type.
+ * @param distance The distance type.
+ * @return The distance function.
+ */
+export function getDistanceCalculationFunction(distanceType) {
+    const distanceFunctions = {
+        cosine: (X, Y) => 1.0 - similarity.cosine(X, Y),
+        euclidean: distance.euclidean,
+        manhattan: distance.manhattan,
+        chebyshev: distance.chebyshev,
+    };
+    return distanceFunctions[distanceType];
+}
+/**
+ * Compute the score based on the distance metric.
+ * @param vectors The input vectors.
+ * @param distanceMetric The distance metric.
+ * @return The computed score.
+ */
+export function computeEvaluationScore(vectors, distanceMetric) {
+    const metricFunction = getDistanceCalculationFunction(distanceMetric);
+    return metricFunction(vectors[0], vectors[1]);
+}
+/**
+ * Use embedding distances to score semantic difference between
+ * a prediction and reference.
+ */
+export class EmbeddingDistanceEvalChain extends StringEvaluator {
+    constructor(fields) {
+        super();
+        Object.defineProperty(this, "requiresReference", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "requiresInput", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "outputKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "score"
+        });
+        Object.defineProperty(this, "embedding", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "distanceMetric", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "cosine"
+        });
+        this.embedding = fields?.embedding || new OpenAIEmbeddings();
+        this.distanceMetric = fields?.distanceMetric || "cosine";
+    }
+    _chainType() {
+        return `embedding_${this.distanceMetric}_distance`;
+    }
+    async _evaluateStrings(args, config) {
+        const result = await this.call(args, config);
+        return { [this.outputKey]: result[this.outputKey] };
+    }
+    get inputKeys() {
+        return ["reference", "prediction"];
+    }
+    get outputKeys() {
+        return [this.outputKey];
+    }
+    async _call(values, _runManager) {
+        const { prediction, reference } = values;
+        if (!this.embedding)
+            throw new Error("Embedding is undefined");
+        const vectors = await this.embedding.embedDocuments([
+            prediction,
+            reference,
+        ]);
+        const score = computeEvaluationScore(vectors, this.distanceMetric);
+        return { [this.outputKey]: score };
+    }
+}
+/**
+ * Use embedding distances to score semantic difference between two predictions.
+ */
+export class PairwiseEmbeddingDistanceEvalChain extends PairwiseStringEvaluator {
+    constructor(fields) {
+        super();
+        Object.defineProperty(this, "requiresReference", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "requiresInput", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "outputKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "score"
+        });
+        Object.defineProperty(this, "embedding", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "distanceMetric", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "cosine"
+        });
+        this.embedding = fields?.embedding || new OpenAIEmbeddings();
+        this.distanceMetric = fields?.distanceMetric || "cosine";
+    }
+    _chainType() {
+        return `pairwise_embedding_${this.distanceMetric}_distance`;
+    }
+    async _evaluateStringPairs(args, config) {
+        const result = await this.call(args, config);
+        return { [this.outputKey]: result[this.outputKey] };
+    }
+    get inputKeys() {
+        return ["prediction", "predictionB"];
+    }
+    get outputKeys() {
+        return [this.outputKey];
+    }
+    async _call(values, _runManager) {
+        const { prediction, predictionB } = values;
+        if (!this.embedding)
+            throw new Error("Embedding is undefined");
+        const vectors = await this.embedding.embedDocuments([
+            prediction,
+            predictionB,
+        ]);
+        const score = computeEvaluationScore(vectors, this.distanceMetric);
+        return { [this.outputKey]: score };
+    }
+}

package/dist/evaluation/embedding_distance/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base.cjs"), exports);

package/dist/evaluation/embedding_distance/index.d.ts

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

package/dist/evaluation/embedding_distance/index.js

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

package/dist/evaluation/index.cjs

@@ -15,3 +15,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./qa/index.cjs"), exports);
+__exportStar(require("./criteria/index.cjs"), exports);
+__exportStar(require("./agents/index.cjs"), exports);
+__exportStar(require("./embedding_distance/index.cjs"), exports);
+__exportStar(require("./comparison/index.cjs"), exports);
+__exportStar(require("./types.cjs"), exports);
+__exportStar(require("./loader.cjs"), exports);

package/dist/evaluation/index.d.ts

@@ -1 +1,7 @@
 export * from "./qa/index.js";
+export * from "./criteria/index.js";
+export * from "./agents/index.js";
+export * from "./embedding_distance/index.js";
+export * from "./comparison/index.js";
+export * from "./types.js";
+export * from "./loader.js";

package/dist/evaluation/index.js

@@ -1 +1,7 @@
 export * from "./qa/index.js";
+export * from "./criteria/index.js";
+export * from "./agents/index.js";
+export * from "./embedding_distance/index.js";
+export * from "./comparison/index.js";
+export * from "./types.js";
+export * from "./loader.js";

package/dist/evaluation/loader.cjs

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEvaluator = void 0;
+const index_js_1 = require("./criteria/index.cjs");
+const openai_js_1 = require("../chat_models/openai.cjs");
+const index_js_2 = require("./comparison/index.cjs");
+const index_js_3 = require("./embedding_distance/index.cjs");
+const index_js_4 = require("./agents/index.cjs");
+const base_js_1 = require("../chat_models/base.cjs");
+/**
+ * Load the requested evaluation chain specified by a string
+ * @param type The type of evaluator to load.
+ * @param options
+ *        - llm The language model to use for the evaluator.
+ *        - criteria The criteria to use for the evaluator.
+ *        - agentTools A list of tools available to the agent,for TrajectoryEvalChain.
+ */
+async function loadEvaluator(type, options) {
+    const { llm, chainOptions, criteria, agentTools } = options || {};
+    const llm_ = llm ??
+        new openai_js_1.ChatOpenAI({
+            modelName: "gpt-4",
+            temperature: 0.0,
+        });
+    let evaluator;
+    switch (type) {
+        case "criteria":
+            evaluator = await index_js_1.CriteriaEvalChain.fromLLM(llm_, criteria, chainOptions);
+            break;
+        case "labeled_criteria":
+            evaluator = await index_js_1.LabeledCriteriaEvalChain.fromLLM(llm_, criteria, chainOptions);
+            break;
+        case "pairwise_string":
+            evaluator = await index_js_2.PairwiseStringEvalChain.fromLLM(llm_, criteria, chainOptions);
+            break;
+        case "labeled_pairwise_string":
+            evaluator = await index_js_2.LabeledPairwiseStringEvalChain.fromLLM(llm_, criteria, chainOptions);
+            break;
+        case "trajectory":
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            if (!(llm_ instanceof base_js_1.BaseChatModel)) {
+                throw new Error("LLM must be an instance of a base chat model.");
+            }
+            evaluator = await index_js_4.TrajectoryEvalChain.fromLLM(llm_, agentTools, chainOptions);
+            break;
+        case "embedding_distance":
+            evaluator = new index_js_3.EmbeddingDistanceEvalChain({
+                embedding: options?.embedding,
+                distanceMetric: options?.distanceMetric,
+            });
+            break;
+        case "pairwise_embedding_distance":
+            evaluator = new index_js_3.PairwiseEmbeddingDistanceEvalChain({});
+            break;
+        default:
+            throw new Error(`Unknown type: ${type}`);
+    }
+    return evaluator;
+}
+exports.loadEvaluator = loadEvaluator;

package/dist/evaluation/loader.d.ts

@@ -0,0 +1,27 @@
+import { BaseLanguageModel } from "../base_language/index.js";
+import { CriteriaLike } from "./criteria/index.js";
+import type { EvaluatorType } from "./types.js";
+import { StructuredTool } from "../tools/index.js";
+import { LLMEvalChainInput } from "./base.js";
+import { EmbeddingDistanceEvalChainInput } from "./embedding_distance/index.js";
+export type LoadEvaluatorOptions = EmbeddingDistanceEvalChainInput & {
+    llm?: BaseLanguageModel;
+    chainOptions?: Partial<Omit<LLMEvalChainInput, "llm">>;
+    /**
+     * The criteria to use for the evaluator.
+     */
+    criteria?: CriteriaLike;
+    /**
+     * A list of tools available to the agent, for TrajectoryEvalChain.
+     */
+    agentTools?: StructuredTool[];
+};
+/**
+ * Load the requested evaluation chain specified by a string
+ * @param type The type of evaluator to load.
+ * @param options
+ *        - llm The language model to use for the evaluator.
+ *        - criteria The criteria to use for the evaluator.
+ *        - agentTools A list of tools available to the agent,for TrajectoryEvalChain.
+ */
+export declare function loadEvaluator<T extends keyof EvaluatorType>(type: T, options?: LoadEvaluatorOptions): Promise<EvaluatorType[T]>;