langchain 1.0.0-alpha.5 → 1.0.0-alpha.7

package/dist/embeddings/cache_backed.cjs

@@ -118,7 +118,7 @@ var CacheBackedEmbeddings = class extends __langchain_core_embeddings.Embeddings
 		const decoder = new TextDecoder();
 		const encoderBackedStore = new require_storage_encoder_backed.EncoderBackedStore({
 			store: documentEmbeddingStore,
-			keyEncoder: (key) => (options?.namespace ?? "") + (0, __langchain_core_utils_hash.insecureHash)(key),
+			keyEncoder: (key) => (options?.namespace ?? "") + (0, __langchain_core_utils_hash.sha256)(key),
 			valueSerializer: (value) => encoder.encode(JSON.stringify(value)),
 			valueDeserializer: (serializedValue) => JSON.parse(decoder.decode(serializedValue))
 		});

package/dist/embeddings/cache_backed.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"cache_backed.cjs","names":["Embeddings","fields: CacheBackedEmbeddingsFields","document: string","documents: string[]","keyValuePairs: [string, number[]][]","underlyingEmbeddings: EmbeddingsInterface","documentEmbeddingStore: BaseStore<string, Uint8Array>","options?: {\n      namespace?: string;\n    }","EncoderBackedStore"],"sources":["../../src/embeddings/cache_backed.ts"],"sourcesContent":["import { insecureHash } from \"@langchain/core/utils/hash\";\nimport {\n  type EmbeddingsInterface,\n  Embeddings,\n} from \"@langchain/core/embeddings\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\nimport { AsyncCallerParams } from \"@langchain/core/utils/async_caller\";\nimport { EncoderBackedStore } from \"../storage/encoder_backed.js\";\n\n/**\n * Interface for the fields required to initialize an instance of the\n * CacheBackedEmbeddings class.\n */\nexport interface CacheBackedEmbeddingsFields extends AsyncCallerParams {\n  underlyingEmbeddings: EmbeddingsInterface;\n  documentEmbeddingStore: BaseStore<string, number[]>;\n}\n\n/**\n * Interface for caching results from embedding models.\n *\n * The interface allows works with any store that implements\n * the abstract store interface accepting keys of type str and values of list of\n * floats.\n *\n * If need be, the interface can be extended to accept other implementations\n * of the value serializer and deserializer, as well as the key encoder.\n * @example\n * ```typescript\n * const underlyingEmbeddings = new OpenAIEmbeddings();\n *\n * const cacheBackedEmbeddings = CacheBackedEmbeddings.fromBytesStore(\n *   underlyingEmbeddings,\n *   new ConvexKVStore({ ctx }),\n *   {\n *     namespace: underlyingEmbeddings.modelName,\n *   },\n * );\n *\n * const loader = new TextLoader(\"./state_of_the_union.txt\");\n * const rawDocuments = await loader.load();\n * const splitter = new RecursiveCharacterTextSplitter({\n *   chunkSize: 1000,\n *   chunkOverlap: 0,\n * });\n * const documents = await splitter.splitDocuments(rawDocuments);\n *\n * let time = Date.now();\n * const vectorstore = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Initial creation time: ${Date.now() - time}ms`);\n *\n * time = Date.now();\n * const vectorstore2 = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Cached creation time: ${Date.now() - time}ms`);\n *\n * ```\n */\nexport class CacheBackedEmbeddings extends Embeddings {\n  protected underlyingEmbeddings: EmbeddingsInterface;\n\n  protected documentEmbeddingStore: BaseStore<string, number[]>;\n\n  constructor(fields: CacheBackedEmbeddingsFields) {\n    super(fields);\n    this.underlyingEmbeddings = fields.underlyingEmbeddings;\n    this.documentEmbeddingStore = fields.documentEmbeddingStore;\n  }\n\n  /**\n   * Embed query text.\n   *\n   * This method does not support caching at the moment.\n   *\n   * Support for caching queries is easy to implement, but might make\n   * sense to hold off to see the most common patterns.\n   *\n   * If the cache has an eviction policy, we may need to be a bit more careful\n   * about sharing the cache between documents and queries. Generally,\n   * one is OK evicting query caches, but document caches should be kept.\n   *\n   * @param document The text to embed.\n   * @returns The embedding for the given text.\n   */\n  async embedQuery(document: string): Promise<number[]> {\n    return this.underlyingEmbeddings.embedQuery(document);\n  }\n\n  /**\n   * Embed a list of texts.\n   *\n   * The method first checks the cache for the embeddings.\n   * If the embeddings are not found, the method uses the underlying embedder\n   * to embed the documents and stores the results in the cache.\n   *\n   * @param documents\n   * @returns A list of embeddings for the given texts.\n   */\n  async embedDocuments(documents: string[]): Promise<number[][]> {\n    const vectors = await this.documentEmbeddingStore.mget(documents);\n    const missingIndicies = [];\n    const missingDocuments = [];\n    for (let i = 0; i < vectors.length; i += 1) {\n      if (vectors[i] === undefined) {\n        missingIndicies.push(i);\n        missingDocuments.push(documents[i]);\n      }\n    }\n    if (missingDocuments.length) {\n      const missingVectors = await this.underlyingEmbeddings.embedDocuments(\n        missingDocuments\n      );\n      const keyValuePairs: [string, number[]][] = missingDocuments.map(\n        (document, i) => [document, missingVectors[i]]\n      );\n      await this.documentEmbeddingStore.mset(keyValuePairs);\n      for (let i = 0; i < missingIndicies.length; i += 1) {\n        vectors[missingIndicies[i]] = missingVectors[i];\n      }\n    }\n    return vectors as number[][];\n  }\n\n  /**\n   * Create a new CacheBackedEmbeddings instance from another embeddings instance\n   * and a storage instance.\n   * @param underlyingEmbeddings Embeddings used to populate the cache for new documents.\n   * @param documentEmbeddingStore Stores raw document embedding values. Keys are hashes of the document content.\n   * @param options.namespace Optional namespace for store keys.\n   * @returns A new CacheBackedEmbeddings instance.\n   */\n  static fromBytesStore(\n    underlyingEmbeddings: EmbeddingsInterface,\n    documentEmbeddingStore: BaseStore<string, Uint8Array>,\n    options?: {\n      namespace?: string;\n    }\n  ) {\n    const encoder = new TextEncoder();\n    const decoder = new TextDecoder();\n    const encoderBackedStore = new EncoderBackedStore<\n      string,\n      number[],\n      Uint8Array\n    >({\n      store: documentEmbeddingStore,\n      keyEncoder: (key) => (options?.namespace ?? \"\") + insecureHash(key),\n      valueSerializer: (value) => encoder.encode(JSON.stringify(value)),\n      valueDeserializer: (serializedValue) =>\n        JSON.parse(decoder.decode(serializedValue)),\n    });\n    return new this({\n      underlyingEmbeddings,\n      documentEmbeddingStore: encoderBackedStore,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,IAAa,wBAAb,cAA2CA,uCAAW;CACpD,AAAU;CAEV,AAAU;CAEV,YAAYC,QAAqC;EAC/C,MAAM,OAAO;EACb,KAAK,uBAAuB,OAAO;EACnC,KAAK,yBAAyB,OAAO;CACtC;;;;;;;;;;;;;;;;CAiBD,MAAM,WAAWC,UAAqC;AACpD,SAAO,KAAK,qBAAqB,WAAW,SAAS;CACtD;;;;;;;;;;;CAYD,MAAM,eAAeC,WAA0C;EAC7D,MAAM,UAAU,MAAM,KAAK,uBAAuB,KAAK,UAAU;EACjE,MAAM,kBAAkB,CAAE;EAC1B,MAAM,mBAAmB,CAAE;AAC3B,OAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK,EACvC,KAAI,QAAQ,OAAO,QAAW;GAC5B,gBAAgB,KAAK,EAAE;GACvB,iBAAiB,KAAK,UAAU,GAAG;EACpC;AAEH,MAAI,iBAAiB,QAAQ;GAC3B,MAAM,iBAAiB,MAAM,KAAK,qBAAqB,eACrD,iBACD;GACD,MAAMC,gBAAsC,iBAAiB,IAC3D,CAAC,UAAU,MAAM,CAAC,UAAU,eAAe,EAAG,EAC/C;GACD,MAAM,KAAK,uBAAuB,KAAK,cAAc;AACrD,QAAK,IAAI,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK,GAC/C,QAAQ,gBAAgB,MAAM,eAAe;EAEhD;AACD,SAAO;CACR;;;;;;;;;CAUD,OAAO,eACLC,sBACAC,wBACAC,SAGA;EACA,MAAM,UAAU,IAAI;EACpB,MAAM,UAAU,IAAI;EACpB,MAAM,qBAAqB,IAAIC,kDAI7B;GACA,OAAO;GACP,YAAY,CAAC,SAAS,SAAS,aAAa,oDAAmB,IAAI;GACnE,iBAAiB,CAAC,UAAU,QAAQ,OAAO,KAAK,UAAU,MAAM,CAAC;GACjE,mBAAmB,CAAC,oBAClB,KAAK,MAAM,QAAQ,OAAO,gBAAgB,CAAC;EAC9C;AACD,SAAO,IAAI,KAAK;GACd;GACA,wBAAwB;EACzB;CACF;AACF"}
+{"version":3,"file":"cache_backed.cjs","names":["Embeddings","fields: CacheBackedEmbeddingsFields","document: string","documents: string[]","keyValuePairs: [string, number[]][]","underlyingEmbeddings: EmbeddingsInterface","documentEmbeddingStore: BaseStore<string, Uint8Array>","options?: {\n      namespace?: string;\n    }","EncoderBackedStore"],"sources":["../../src/embeddings/cache_backed.ts"],"sourcesContent":["import { sha256 } from \"@langchain/core/utils/hash\";\nimport {\n  type EmbeddingsInterface,\n  Embeddings,\n} from \"@langchain/core/embeddings\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\nimport { AsyncCallerParams } from \"@langchain/core/utils/async_caller\";\nimport { EncoderBackedStore } from \"../storage/encoder_backed.js\";\n\n/**\n * Interface for the fields required to initialize an instance of the\n * CacheBackedEmbeddings class.\n */\nexport interface CacheBackedEmbeddingsFields extends AsyncCallerParams {\n  underlyingEmbeddings: EmbeddingsInterface;\n  documentEmbeddingStore: BaseStore<string, number[]>;\n}\n\n/**\n * Interface for caching results from embedding models.\n *\n * The interface allows works with any store that implements\n * the abstract store interface accepting keys of type str and values of list of\n * floats.\n *\n * If need be, the interface can be extended to accept other implementations\n * of the value serializer and deserializer, as well as the key encoder.\n * @example\n * ```typescript\n * const underlyingEmbeddings = new OpenAIEmbeddings();\n *\n * const cacheBackedEmbeddings = CacheBackedEmbeddings.fromBytesStore(\n *   underlyingEmbeddings,\n *   new ConvexKVStore({ ctx }),\n *   {\n *     namespace: underlyingEmbeddings.modelName,\n *   },\n * );\n *\n * const loader = new TextLoader(\"./state_of_the_union.txt\");\n * const rawDocuments = await loader.load();\n * const splitter = new RecursiveCharacterTextSplitter({\n *   chunkSize: 1000,\n *   chunkOverlap: 0,\n * });\n * const documents = await splitter.splitDocuments(rawDocuments);\n *\n * let time = Date.now();\n * const vectorstore = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Initial creation time: ${Date.now() - time}ms`);\n *\n * time = Date.now();\n * const vectorstore2 = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Cached creation time: ${Date.now() - time}ms`);\n *\n * ```\n */\nexport class CacheBackedEmbeddings extends Embeddings {\n  protected underlyingEmbeddings: EmbeddingsInterface;\n\n  protected documentEmbeddingStore: BaseStore<string, number[]>;\n\n  constructor(fields: CacheBackedEmbeddingsFields) {\n    super(fields);\n    this.underlyingEmbeddings = fields.underlyingEmbeddings;\n    this.documentEmbeddingStore = fields.documentEmbeddingStore;\n  }\n\n  /**\n   * Embed query text.\n   *\n   * This method does not support caching at the moment.\n   *\n   * Support for caching queries is easy to implement, but might make\n   * sense to hold off to see the most common patterns.\n   *\n   * If the cache has an eviction policy, we may need to be a bit more careful\n   * about sharing the cache between documents and queries. Generally,\n   * one is OK evicting query caches, but document caches should be kept.\n   *\n   * @param document The text to embed.\n   * @returns The embedding for the given text.\n   */\n  async embedQuery(document: string): Promise<number[]> {\n    return this.underlyingEmbeddings.embedQuery(document);\n  }\n\n  /**\n   * Embed a list of texts.\n   *\n   * The method first checks the cache for the embeddings.\n   * If the embeddings are not found, the method uses the underlying embedder\n   * to embed the documents and stores the results in the cache.\n   *\n   * @param documents\n   * @returns A list of embeddings for the given texts.\n   */\n  async embedDocuments(documents: string[]): Promise<number[][]> {\n    const vectors = await this.documentEmbeddingStore.mget(documents);\n    const missingIndicies = [];\n    const missingDocuments = [];\n    for (let i = 0; i < vectors.length; i += 1) {\n      if (vectors[i] === undefined) {\n        missingIndicies.push(i);\n        missingDocuments.push(documents[i]);\n      }\n    }\n    if (missingDocuments.length) {\n      const missingVectors = await this.underlyingEmbeddings.embedDocuments(\n        missingDocuments\n      );\n      const keyValuePairs: [string, number[]][] = missingDocuments.map(\n        (document, i) => [document, missingVectors[i]]\n      );\n      await this.documentEmbeddingStore.mset(keyValuePairs);\n      for (let i = 0; i < missingIndicies.length; i += 1) {\n        vectors[missingIndicies[i]] = missingVectors[i];\n      }\n    }\n    return vectors as number[][];\n  }\n\n  /**\n   * Create a new CacheBackedEmbeddings instance from another embeddings instance\n   * and a storage instance.\n   * @param underlyingEmbeddings Embeddings used to populate the cache for new documents.\n   * @param documentEmbeddingStore Stores raw document embedding values. Keys are hashes of the document content.\n   * @param options.namespace Optional namespace for store keys.\n   * @returns A new CacheBackedEmbeddings instance.\n   */\n  static fromBytesStore(\n    underlyingEmbeddings: EmbeddingsInterface,\n    documentEmbeddingStore: BaseStore<string, Uint8Array>,\n    options?: {\n      namespace?: string;\n    }\n  ) {\n    const encoder = new TextEncoder();\n    const decoder = new TextDecoder();\n    const encoderBackedStore = new EncoderBackedStore<\n      string,\n      number[],\n      Uint8Array\n    >({\n      store: documentEmbeddingStore,\n      keyEncoder: (key) => (options?.namespace ?? \"\") + sha256(key),\n      valueSerializer: (value) => encoder.encode(JSON.stringify(value)),\n      valueDeserializer: (serializedValue) =>\n        JSON.parse(decoder.decode(serializedValue)),\n    });\n    return new this({\n      underlyingEmbeddings,\n      documentEmbeddingStore: encoderBackedStore,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,IAAa,wBAAb,cAA2CA,uCAAW;CACpD,AAAU;CAEV,AAAU;CAEV,YAAYC,QAAqC;EAC/C,MAAM,OAAO;EACb,KAAK,uBAAuB,OAAO;EACnC,KAAK,yBAAyB,OAAO;CACtC;;;;;;;;;;;;;;;;CAiBD,MAAM,WAAWC,UAAqC;AACpD,SAAO,KAAK,qBAAqB,WAAW,SAAS;CACtD;;;;;;;;;;;CAYD,MAAM,eAAeC,WAA0C;EAC7D,MAAM,UAAU,MAAM,KAAK,uBAAuB,KAAK,UAAU;EACjE,MAAM,kBAAkB,CAAE;EAC1B,MAAM,mBAAmB,CAAE;AAC3B,OAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK,EACvC,KAAI,QAAQ,OAAO,QAAW;GAC5B,gBAAgB,KAAK,EAAE;GACvB,iBAAiB,KAAK,UAAU,GAAG;EACpC;AAEH,MAAI,iBAAiB,QAAQ;GAC3B,MAAM,iBAAiB,MAAM,KAAK,qBAAqB,eACrD,iBACD;GACD,MAAMC,gBAAsC,iBAAiB,IAC3D,CAAC,UAAU,MAAM,CAAC,UAAU,eAAe,EAAG,EAC/C;GACD,MAAM,KAAK,uBAAuB,KAAK,cAAc;AACrD,QAAK,IAAI,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK,GAC/C,QAAQ,gBAAgB,MAAM,eAAe;EAEhD;AACD,SAAO;CACR;;;;;;;;;CAUD,OAAO,eACLC,sBACAC,wBACAC,SAGA;EACA,MAAM,UAAU,IAAI;EACpB,MAAM,UAAU,IAAI;EACpB,MAAM,qBAAqB,IAAIC,kDAI7B;GACA,OAAO;GACP,YAAY,CAAC,SAAS,SAAS,aAAa,8CAAa,IAAI;GAC7D,iBAAiB,CAAC,UAAU,QAAQ,OAAO,KAAK,UAAU,MAAM,CAAC;GACjE,mBAAmB,CAAC,oBAClB,KAAK,MAAM,QAAQ,OAAO,gBAAgB,CAAC;EAC9C;AACD,SAAO,IAAI,KAAK;GACd;GACA,wBAAwB;EACzB;CACF;AACF"}

package/dist/embeddings/cache_backed.d.cts

@@ -1,6 +1,6 @@
-import { AsyncCallerParams } from "@langchain/core/utils/async_caller";
 import { Embeddings, EmbeddingsInterface } from "@langchain/core/embeddings";
 import { BaseStore } from "@langchain/core/stores";
+import { AsyncCallerParams } from "@langchain/core/utils/async_caller";
 
 //#region src/embeddings/cache_backed.d.ts
 

package/dist/embeddings/cache_backed.d.ts

@@ -1,6 +1,6 @@
-import { AsyncCallerParams } from "@langchain/core/utils/async_caller";
-import { Embeddings, EmbeddingsInterface } from "@langchain/core/embeddings";
 import { BaseStore } from "@langchain/core/stores";
+import { Embeddings, EmbeddingsInterface } from "@langchain/core/embeddings";
+import { AsyncCallerParams } from "@langchain/core/utils/async_caller";
 
 //#region src/embeddings/cache_backed.d.ts
 

package/dist/embeddings/cache_backed.js

@@ -1,6 +1,6 @@
 import { __export } from "../_virtual/rolldown_runtime.js";
 import { EncoderBackedStore } from "../storage/encoder_backed.js";
-import { insecureHash } from "@langchain/core/utils/hash";
+import { sha256 } from "@langchain/core/utils/hash";
 import { Embeddings } from "@langchain/core/embeddings";
 
 //#region src/embeddings/cache_backed.ts
@@ -118,7 +118,7 @@ var CacheBackedEmbeddings = class extends Embeddings {
 		const decoder = new TextDecoder();
 		const encoderBackedStore = new EncoderBackedStore({
 			store: documentEmbeddingStore,
-			keyEncoder: (key) => (options?.namespace ?? "") + insecureHash(key),
+			keyEncoder: (key) => (options?.namespace ?? "") + sha256(key),
 			valueSerializer: (value) => encoder.encode(JSON.stringify(value)),
 			valueDeserializer: (serializedValue) => JSON.parse(decoder.decode(serializedValue))
 		});

package/dist/embeddings/cache_backed.js.map

@@ -1 +1 @@
-{"version":3,"file":"cache_backed.js","names":["fields: CacheBackedEmbeddingsFields","document: string","documents: string[]","keyValuePairs: [string, number[]][]","underlyingEmbeddings: EmbeddingsInterface","documentEmbeddingStore: BaseStore<string, Uint8Array>","options?: {\n      namespace?: string;\n    }"],"sources":["../../src/embeddings/cache_backed.ts"],"sourcesContent":["import { insecureHash } from \"@langchain/core/utils/hash\";\nimport {\n  type EmbeddingsInterface,\n  Embeddings,\n} from \"@langchain/core/embeddings\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\nimport { AsyncCallerParams } from \"@langchain/core/utils/async_caller\";\nimport { EncoderBackedStore } from \"../storage/encoder_backed.js\";\n\n/**\n * Interface for the fields required to initialize an instance of the\n * CacheBackedEmbeddings class.\n */\nexport interface CacheBackedEmbeddingsFields extends AsyncCallerParams {\n  underlyingEmbeddings: EmbeddingsInterface;\n  documentEmbeddingStore: BaseStore<string, number[]>;\n}\n\n/**\n * Interface for caching results from embedding models.\n *\n * The interface allows works with any store that implements\n * the abstract store interface accepting keys of type str and values of list of\n * floats.\n *\n * If need be, the interface can be extended to accept other implementations\n * of the value serializer and deserializer, as well as the key encoder.\n * @example\n * ```typescript\n * const underlyingEmbeddings = new OpenAIEmbeddings();\n *\n * const cacheBackedEmbeddings = CacheBackedEmbeddings.fromBytesStore(\n *   underlyingEmbeddings,\n *   new ConvexKVStore({ ctx }),\n *   {\n *     namespace: underlyingEmbeddings.modelName,\n *   },\n * );\n *\n * const loader = new TextLoader(\"./state_of_the_union.txt\");\n * const rawDocuments = await loader.load();\n * const splitter = new RecursiveCharacterTextSplitter({\n *   chunkSize: 1000,\n *   chunkOverlap: 0,\n * });\n * const documents = await splitter.splitDocuments(rawDocuments);\n *\n * let time = Date.now();\n * const vectorstore = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Initial creation time: ${Date.now() - time}ms`);\n *\n * time = Date.now();\n * const vectorstore2 = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Cached creation time: ${Date.now() - time}ms`);\n *\n * ```\n */\nexport class CacheBackedEmbeddings extends Embeddings {\n  protected underlyingEmbeddings: EmbeddingsInterface;\n\n  protected documentEmbeddingStore: BaseStore<string, number[]>;\n\n  constructor(fields: CacheBackedEmbeddingsFields) {\n    super(fields);\n    this.underlyingEmbeddings = fields.underlyingEmbeddings;\n    this.documentEmbeddingStore = fields.documentEmbeddingStore;\n  }\n\n  /**\n   * Embed query text.\n   *\n   * This method does not support caching at the moment.\n   *\n   * Support for caching queries is easy to implement, but might make\n   * sense to hold off to see the most common patterns.\n   *\n   * If the cache has an eviction policy, we may need to be a bit more careful\n   * about sharing the cache between documents and queries. Generally,\n   * one is OK evicting query caches, but document caches should be kept.\n   *\n   * @param document The text to embed.\n   * @returns The embedding for the given text.\n   */\n  async embedQuery(document: string): Promise<number[]> {\n    return this.underlyingEmbeddings.embedQuery(document);\n  }\n\n  /**\n   * Embed a list of texts.\n   *\n   * The method first checks the cache for the embeddings.\n   * If the embeddings are not found, the method uses the underlying embedder\n   * to embed the documents and stores the results in the cache.\n   *\n   * @param documents\n   * @returns A list of embeddings for the given texts.\n   */\n  async embedDocuments(documents: string[]): Promise<number[][]> {\n    const vectors = await this.documentEmbeddingStore.mget(documents);\n    const missingIndicies = [];\n    const missingDocuments = [];\n    for (let i = 0; i < vectors.length; i += 1) {\n      if (vectors[i] === undefined) {\n        missingIndicies.push(i);\n        missingDocuments.push(documents[i]);\n      }\n    }\n    if (missingDocuments.length) {\n      const missingVectors = await this.underlyingEmbeddings.embedDocuments(\n        missingDocuments\n      );\n      const keyValuePairs: [string, number[]][] = missingDocuments.map(\n        (document, i) => [document, missingVectors[i]]\n      );\n      await this.documentEmbeddingStore.mset(keyValuePairs);\n      for (let i = 0; i < missingIndicies.length; i += 1) {\n        vectors[missingIndicies[i]] = missingVectors[i];\n      }\n    }\n    return vectors as number[][];\n  }\n\n  /**\n   * Create a new CacheBackedEmbeddings instance from another embeddings instance\n   * and a storage instance.\n   * @param underlyingEmbeddings Embeddings used to populate the cache for new documents.\n   * @param documentEmbeddingStore Stores raw document embedding values. Keys are hashes of the document content.\n   * @param options.namespace Optional namespace for store keys.\n   * @returns A new CacheBackedEmbeddings instance.\n   */\n  static fromBytesStore(\n    underlyingEmbeddings: EmbeddingsInterface,\n    documentEmbeddingStore: BaseStore<string, Uint8Array>,\n    options?: {\n      namespace?: string;\n    }\n  ) {\n    const encoder = new TextEncoder();\n    const decoder = new TextDecoder();\n    const encoderBackedStore = new EncoderBackedStore<\n      string,\n      number[],\n      Uint8Array\n    >({\n      store: documentEmbeddingStore,\n      keyEncoder: (key) => (options?.namespace ?? \"\") + insecureHash(key),\n      valueSerializer: (value) => encoder.encode(JSON.stringify(value)),\n      valueDeserializer: (serializedValue) =>\n        JSON.parse(decoder.decode(serializedValue)),\n    });\n    return new this({\n      underlyingEmbeddings,\n      documentEmbeddingStore: encoderBackedStore,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,IAAa,wBAAb,cAA2C,WAAW;CACpD,AAAU;CAEV,AAAU;CAEV,YAAYA,QAAqC;EAC/C,MAAM,OAAO;EACb,KAAK,uBAAuB,OAAO;EACnC,KAAK,yBAAyB,OAAO;CACtC;;;;;;;;;;;;;;;;CAiBD,MAAM,WAAWC,UAAqC;AACpD,SAAO,KAAK,qBAAqB,WAAW,SAAS;CACtD;;;;;;;;;;;CAYD,MAAM,eAAeC,WAA0C;EAC7D,MAAM,UAAU,MAAM,KAAK,uBAAuB,KAAK,UAAU;EACjE,MAAM,kBAAkB,CAAE;EAC1B,MAAM,mBAAmB,CAAE;AAC3B,OAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK,EACvC,KAAI,QAAQ,OAAO,QAAW;GAC5B,gBAAgB,KAAK,EAAE;GACvB,iBAAiB,KAAK,UAAU,GAAG;EACpC;AAEH,MAAI,iBAAiB,QAAQ;GAC3B,MAAM,iBAAiB,MAAM,KAAK,qBAAqB,eACrD,iBACD;GACD,MAAMC,gBAAsC,iBAAiB,IAC3D,CAAC,UAAU,MAAM,CAAC,UAAU,eAAe,EAAG,EAC/C;GACD,MAAM,KAAK,uBAAuB,KAAK,cAAc;AACrD,QAAK,IAAI,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK,GAC/C,QAAQ,gBAAgB,MAAM,eAAe;EAEhD;AACD,SAAO;CACR;;;;;;;;;CAUD,OAAO,eACLC,sBACAC,wBACAC,SAGA;EACA,MAAM,UAAU,IAAI;EACpB,MAAM,UAAU,IAAI;EACpB,MAAM,qBAAqB,IAAI,mBAI7B;GACA,OAAO;GACP,YAAY,CAAC,SAAS,SAAS,aAAa,MAAM,aAAa,IAAI;GACnE,iBAAiB,CAAC,UAAU,QAAQ,OAAO,KAAK,UAAU,MAAM,CAAC;GACjE,mBAAmB,CAAC,oBAClB,KAAK,MAAM,QAAQ,OAAO,gBAAgB,CAAC;EAC9C;AACD,SAAO,IAAI,KAAK;GACd;GACA,wBAAwB;EACzB;CACF;AACF"}
+{"version":3,"file":"cache_backed.js","names":["fields: CacheBackedEmbeddingsFields","document: string","documents: string[]","keyValuePairs: [string, number[]][]","underlyingEmbeddings: EmbeddingsInterface","documentEmbeddingStore: BaseStore<string, Uint8Array>","options?: {\n      namespace?: string;\n    }"],"sources":["../../src/embeddings/cache_backed.ts"],"sourcesContent":["import { sha256 } from \"@langchain/core/utils/hash\";\nimport {\n  type EmbeddingsInterface,\n  Embeddings,\n} from \"@langchain/core/embeddings\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\nimport { AsyncCallerParams } from \"@langchain/core/utils/async_caller\";\nimport { EncoderBackedStore } from \"../storage/encoder_backed.js\";\n\n/**\n * Interface for the fields required to initialize an instance of the\n * CacheBackedEmbeddings class.\n */\nexport interface CacheBackedEmbeddingsFields extends AsyncCallerParams {\n  underlyingEmbeddings: EmbeddingsInterface;\n  documentEmbeddingStore: BaseStore<string, number[]>;\n}\n\n/**\n * Interface for caching results from embedding models.\n *\n * The interface allows works with any store that implements\n * the abstract store interface accepting keys of type str and values of list of\n * floats.\n *\n * If need be, the interface can be extended to accept other implementations\n * of the value serializer and deserializer, as well as the key encoder.\n * @example\n * ```typescript\n * const underlyingEmbeddings = new OpenAIEmbeddings();\n *\n * const cacheBackedEmbeddings = CacheBackedEmbeddings.fromBytesStore(\n *   underlyingEmbeddings,\n *   new ConvexKVStore({ ctx }),\n *   {\n *     namespace: underlyingEmbeddings.modelName,\n *   },\n * );\n *\n * const loader = new TextLoader(\"./state_of_the_union.txt\");\n * const rawDocuments = await loader.load();\n * const splitter = new RecursiveCharacterTextSplitter({\n *   chunkSize: 1000,\n *   chunkOverlap: 0,\n * });\n * const documents = await splitter.splitDocuments(rawDocuments);\n *\n * let time = Date.now();\n * const vectorstore = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Initial creation time: ${Date.now() - time}ms`);\n *\n * time = Date.now();\n * const vectorstore2 = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Cached creation time: ${Date.now() - time}ms`);\n *\n * ```\n */\nexport class CacheBackedEmbeddings extends Embeddings {\n  protected underlyingEmbeddings: EmbeddingsInterface;\n\n  protected documentEmbeddingStore: BaseStore<string, number[]>;\n\n  constructor(fields: CacheBackedEmbeddingsFields) {\n    super(fields);\n    this.underlyingEmbeddings = fields.underlyingEmbeddings;\n    this.documentEmbeddingStore = fields.documentEmbeddingStore;\n  }\n\n  /**\n   * Embed query text.\n   *\n   * This method does not support caching at the moment.\n   *\n   * Support for caching queries is easy to implement, but might make\n   * sense to hold off to see the most common patterns.\n   *\n   * If the cache has an eviction policy, we may need to be a bit more careful\n   * about sharing the cache between documents and queries. Generally,\n   * one is OK evicting query caches, but document caches should be kept.\n   *\n   * @param document The text to embed.\n   * @returns The embedding for the given text.\n   */\n  async embedQuery(document: string): Promise<number[]> {\n    return this.underlyingEmbeddings.embedQuery(document);\n  }\n\n  /**\n   * Embed a list of texts.\n   *\n   * The method first checks the cache for the embeddings.\n   * If the embeddings are not found, the method uses the underlying embedder\n   * to embed the documents and stores the results in the cache.\n   *\n   * @param documents\n   * @returns A list of embeddings for the given texts.\n   */\n  async embedDocuments(documents: string[]): Promise<number[][]> {\n    const vectors = await this.documentEmbeddingStore.mget(documents);\n    const missingIndicies = [];\n    const missingDocuments = [];\n    for (let i = 0; i < vectors.length; i += 1) {\n      if (vectors[i] === undefined) {\n        missingIndicies.push(i);\n        missingDocuments.push(documents[i]);\n      }\n    }\n    if (missingDocuments.length) {\n      const missingVectors = await this.underlyingEmbeddings.embedDocuments(\n        missingDocuments\n      );\n      const keyValuePairs: [string, number[]][] = missingDocuments.map(\n        (document, i) => [document, missingVectors[i]]\n      );\n      await this.documentEmbeddingStore.mset(keyValuePairs);\n      for (let i = 0; i < missingIndicies.length; i += 1) {\n        vectors[missingIndicies[i]] = missingVectors[i];\n      }\n    }\n    return vectors as number[][];\n  }\n\n  /**\n   * Create a new CacheBackedEmbeddings instance from another embeddings instance\n   * and a storage instance.\n   * @param underlyingEmbeddings Embeddings used to populate the cache for new documents.\n   * @param documentEmbeddingStore Stores raw document embedding values. Keys are hashes of the document content.\n   * @param options.namespace Optional namespace for store keys.\n   * @returns A new CacheBackedEmbeddings instance.\n   */\n  static fromBytesStore(\n    underlyingEmbeddings: EmbeddingsInterface,\n    documentEmbeddingStore: BaseStore<string, Uint8Array>,\n    options?: {\n      namespace?: string;\n    }\n  ) {\n    const encoder = new TextEncoder();\n    const decoder = new TextDecoder();\n    const encoderBackedStore = new EncoderBackedStore<\n      string,\n      number[],\n      Uint8Array\n    >({\n      store: documentEmbeddingStore,\n      keyEncoder: (key) => (options?.namespace ?? \"\") + sha256(key),\n      valueSerializer: (value) => encoder.encode(JSON.stringify(value)),\n      valueDeserializer: (serializedValue) =>\n        JSON.parse(decoder.decode(serializedValue)),\n    });\n    return new this({\n      underlyingEmbeddings,\n      documentEmbeddingStore: encoderBackedStore,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,IAAa,wBAAb,cAA2C,WAAW;CACpD,AAAU;CAEV,AAAU;CAEV,YAAYA,QAAqC;EAC/C,MAAM,OAAO;EACb,KAAK,uBAAuB,OAAO;EACnC,KAAK,yBAAyB,OAAO;CACtC;;;;;;;;;;;;;;;;CAiBD,MAAM,WAAWC,UAAqC;AACpD,SAAO,KAAK,qBAAqB,WAAW,SAAS;CACtD;;;;;;;;;;;CAYD,MAAM,eAAeC,WAA0C;EAC7D,MAAM,UAAU,MAAM,KAAK,uBAAuB,KAAK,UAAU;EACjE,MAAM,kBAAkB,CAAE;EAC1B,MAAM,mBAAmB,CAAE;AAC3B,OAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK,EACvC,KAAI,QAAQ,OAAO,QAAW;GAC5B,gBAAgB,KAAK,EAAE;GACvB,iBAAiB,KAAK,UAAU,GAAG;EACpC;AAEH,MAAI,iBAAiB,QAAQ;GAC3B,MAAM,iBAAiB,MAAM,KAAK,qBAAqB,eACrD,iBACD;GACD,MAAMC,gBAAsC,iBAAiB,IAC3D,CAAC,UAAU,MAAM,CAAC,UAAU,eAAe,EAAG,EAC/C;GACD,MAAM,KAAK,uBAAuB,KAAK,cAAc;AACrD,QAAK,IAAI,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK,GAC/C,QAAQ,gBAAgB,MAAM,eAAe;EAEhD;AACD,SAAO;CACR;;;;;;;;;CAUD,OAAO,eACLC,sBACAC,wBACAC,SAGA;EACA,MAAM,UAAU,IAAI;EACpB,MAAM,UAAU,IAAI;EACpB,MAAM,qBAAqB,IAAI,mBAI7B;GACA,OAAO;GACP,YAAY,CAAC,SAAS,SAAS,aAAa,MAAM,OAAO,IAAI;GAC7D,iBAAiB,CAAC,UAAU,QAAQ,OAAO,KAAK,UAAU,MAAM,CAAC;GACjE,mBAAmB,CAAC,oBAClB,KAAK,MAAM,QAAQ,OAAO,gBAAgB,CAAC;EAC9C;AACD,SAAO,IAAI,KAAK;GACd;GACA,wBAAwB;EACzB;CACF;AACF"}

package/dist/evaluation/agents/trajectory.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"trajectory.d.cts","names":["StructuredToolInterface","BaseLLMOutputParser","AgentStep","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","BaseChatModel","AgentTrajectoryEvaluator","EvalOutputType","LLMEvalChainInput","LLMTrajectoryEvaluatorArgs","ExtractLLMCallOptions","TrajectoryOutputParser","Promise","TrajectoryEvalChain","____________langchain_core_dist_prompt_values_js0","BasePromptValueInterface","Omit","Partial"],"sources":["../../../src/evaluation/agents/trajectory.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { AgentTrajectoryEvaluator, EvalOutputType, LLMEvalChainInput, LLMTrajectoryEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\n/**\n * A parser for the output of the TrajectoryEvalChain.\n */\nexport declare class TrajectoryOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\n/**\n * A chain for evaluating ReAct style agents.\n *\n * This chain is used to evaluate ReAct style agents by reasoning about\n * the sequence of actions taken and their outcomes.\n */\nexport declare class TrajectoryEvalChain extends AgentTrajectoryEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    outputParser: TrajectoryOutputParser;\n    static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredToolInterface[]): BasePromptTemplate<any, import(\"../../../../langchain-core/dist/prompt_values.js\").BasePromptValueInterface, any>;\n    /**\n     * Get the description of the agent tools.\n     *\n     * @returns The description of the agent tools.\n     */\n    static toolsDescription(agentTools: StructuredToolInterface[]): string;\n    /**\n     * Create a new TrajectoryEvalChain.\n     * @param llm\n     * @param agentTools - The tools used by the agent.\n     * @param chainOptions - The options for the chain.\n     */\n    static fromLLM(llm: BaseChatModel, agentTools?: StructuredToolInterface[], chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<TrajectoryEvalChain>;\n    _prepareOutput(result: ChainValues): any;\n    /**\n     * Get the agent trajectory as a formatted string.\n     *\n     * @param steps - The agent trajectory.\n     * @returns The formatted agent trajectory.\n     */\n    getAgentTrajectory(steps: AgentStep[]): string;\n    formatReference(reference?: string): string;\n    _evaluateAgentTrajectory(args: LLMTrajectoryEvaluatorArgs, callOptions: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAYqBe,cAAAA,sBAAAA,SAA+Bd,mBAAT,CAA6BU,cAA7B,CAAA,CAAA;EAAA,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EAAA,YAA6BA,EAAAA,MAAAA,EAAAA;EAAc,WAGzDN,CAAAA,WAAAA,EAAAA,UAAAA,EAAAA,GAAeD,cAAfC,EAAAA,EAAAA,UAAAA,EAA6CE,SAA7CF,GAAAA,SAAAA,CAAAA,EAAqEW,OAArEX,CAA6EM,cAA7EN,CAAAA;;;;;;AAH0C;AAWvE;AAAwC,cAAnBY,mBAAAA,SAA4BP,wBAAAA,CAAT;EAAA,OAMtBK,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAsB,aACIT,CAAAA,EAAAA,MAAAA;EAAkB,cAA2BN,CAAAA,EAAAA,MAAAA;EAAuB,aAAA,EAAA,OAAA;EAAgH,iBAA3GM,EAAAA,OAAAA;EAAkB,YAM/FN,EAPtBe,sBAOsBf;EAAuB,OAOvCS,uBAAAA,CAAAA,MAAAA,CAAAA,EAboBH,kBAapBG,GAAAA,SAAAA,EAAAA,UAAAA,CAAAA,EAbiET,uBAajES,EAAAA,CAAAA,EAb6FH,kBAa7FG,CAAAA,GAAAA,EAbwF,wBAAA,EAaxFA,GAAAA,CAAAA;EAAa;;;;;EAA8H,OAA3BO,gBAAAA,CAAAA,UAAAA,EAPhGhB,uBAOgGgB,EAAAA,CAAAA,EAAAA,MAAAA;EAAO;;;;;;EAUQ,OAAWb,OAAAA,CAAAA,GAAAA,EAV1IM,aAU0IN,EAAAA,UAAAA,CAAAA,EAV9GH,uBAU8GG,EAAAA,EAAAA,YAAAA,CAAAA,EAVpEkB,OAUoElB,CAV5DiB,IAU4DjB,CAVvDS,iBAUuDT,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAV1Ba,OAU0Bb,CAVlBc,mBAUkBd,CAAAA;EAAW,cAAnBa,CAAAA,MAAAA,EAT/Hb,WAS+Ha,CAAAA,EAAAA,GAAAA;EAAO;AA9BxF;;;;;4BA4B3Cd;;iCAEKW,yCAAyCC,6CAA6CP,YAAYC,qBAAqBQ,QAAQb"}
+{"version":3,"file":"trajectory.d.cts","names":["StructuredToolInterface","BaseLLMOutputParser","AgentStep","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","BaseChatModel","AgentTrajectoryEvaluator","EvalOutputType","LLMEvalChainInput","LLMTrajectoryEvaluatorArgs","ExtractLLMCallOptions","TrajectoryOutputParser","Promise","TrajectoryEvalChain","____________langchain_core_dist_prompt_values_js1","BasePromptValueInterface","Omit","Partial"],"sources":["../../../src/evaluation/agents/trajectory.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { AgentTrajectoryEvaluator, EvalOutputType, LLMEvalChainInput, LLMTrajectoryEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\n/**\n * A parser for the output of the TrajectoryEvalChain.\n */\nexport declare class TrajectoryOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\n/**\n * A chain for evaluating ReAct style agents.\n *\n * This chain is used to evaluate ReAct style agents by reasoning about\n * the sequence of actions taken and their outcomes.\n */\nexport declare class TrajectoryEvalChain extends AgentTrajectoryEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    outputParser: TrajectoryOutputParser;\n    static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredToolInterface[]): BasePromptTemplate<any, import(\"../../../../langchain-core/dist/prompt_values.js\").BasePromptValueInterface, any>;\n    /**\n     * Get the description of the agent tools.\n     *\n     * @returns The description of the agent tools.\n     */\n    static toolsDescription(agentTools: StructuredToolInterface[]): string;\n    /**\n     * Create a new TrajectoryEvalChain.\n     * @param llm\n     * @param agentTools - The tools used by the agent.\n     * @param chainOptions - The options for the chain.\n     */\n    static fromLLM(llm: BaseChatModel, agentTools?: StructuredToolInterface[], chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<TrajectoryEvalChain>;\n    _prepareOutput(result: ChainValues): any;\n    /**\n     * Get the agent trajectory as a formatted string.\n     *\n     * @param steps - The agent trajectory.\n     * @returns The formatted agent trajectory.\n     */\n    getAgentTrajectory(steps: AgentStep[]): string;\n    formatReference(reference?: string): string;\n    _evaluateAgentTrajectory(args: LLMTrajectoryEvaluatorArgs, callOptions: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAYqBe,cAAAA,sBAAAA,SAA+Bd,mBAAT,CAA6BU,cAA7B,CAAA,CAAA;EAAA,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EAAA,YAA6BA,EAAAA,MAAAA,EAAAA;EAAc,WAGzDN,CAAAA,WAAAA,EAAAA,UAAAA,EAAAA,GAAeD,cAAfC,EAAAA,EAAAA,UAAAA,EAA6CE,SAA7CF,GAAAA,SAAAA,CAAAA,EAAqEW,OAArEX,CAA6EM,cAA7EN,CAAAA;;;;;;AAH0C;AAWvE;AAAwC,cAAnBY,mBAAAA,SAA4BP,wBAAAA,CAAT;EAAA,OAMtBK,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAsB,aACIT,CAAAA,EAAAA,MAAAA;EAAkB,cAA2BN,CAAAA,EAAAA,MAAAA;EAAuB,aAAA,EAAA,OAAA;EAAgH,iBAA3GM,EAAAA,OAAAA;EAAkB,YAM/FN,EAPtBe,sBAOsBf;EAAuB,OAOvCS,uBAAAA,CAAAA,MAAAA,CAAAA,EAboBH,kBAapBG,GAAAA,SAAAA,EAAAA,UAAAA,CAAAA,EAbiET,uBAajES,EAAAA,CAAAA,EAb6FH,kBAa7FG,CAAAA,GAAAA,EAbwF,wBAAA,EAaxFA,GAAAA,CAAAA;EAAa;;;;;EAA8H,OAA3BO,gBAAAA,CAAAA,UAAAA,EAPhGhB,uBAOgGgB,EAAAA,CAAAA,EAAAA,MAAAA;EAAO;;;;;;EAUQ,OAAWb,OAAAA,CAAAA,GAAAA,EAV1IM,aAU0IN,EAAAA,UAAAA,CAAAA,EAV9GH,uBAU8GG,EAAAA,EAAAA,YAAAA,CAAAA,EAVpEkB,OAUoElB,CAV5DiB,IAU4DjB,CAVvDS,iBAUuDT,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAV1Ba,OAU0Bb,CAVlBc,mBAUkBd,CAAAA;EAAW,cAAnBa,CAAAA,MAAAA,EAT/Hb,WAS+Ha,CAAAA,EAAAA,GAAAA;EAAO;AA9BxF;;;;;4BA4B3Cd;;iCAEKW,yCAAyCC,6CAA6CP,YAAYC,qBAAqBQ,QAAQb"}

package/dist/evaluation/comparison/pairwise.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"pairwise.d.cts","names":["BaseLanguageModelInterface","BaseLLMOutputParser","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","EvalOutputType","LLMEvalChainInput","LLMPairwiseStringEvaluator","LLMPairwiseStringEvaluatorArgs","ExtractLLMCallOptions","CriteriaLike","PairwiseStringResultOutputParser","Promise","PairwiseStringEvalChain","Record","____________langchain_core_dist_prompt_values_js0","BasePromptValueInterface","Omit","Partial","LabeledPairwiseStringEvalChain"],"sources":["../../../src/evaluation/comparison/pairwise.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { EvalOutputType, LLMEvalChainInput, LLMPairwiseStringEvaluator, LLMPairwiseStringEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\nimport { CriteriaLike } from \"../criteria/criteria.js\";\n/**\n * A parser for the output of the PairwiseStringEvalChain.\n */\nexport declare class PairwiseStringResultOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\n/**\n * A chain for comparing two outputs, such as the outputs\n * of two models, prompts, or outputs of a single model on similar inputs.\n */\nexport declare class PairwiseStringEvalChain extends LLMPairwiseStringEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    skipReferenceWarning: string;\n    outputParser: PairwiseStringResultOutputParser;\n    static resolvePairwiseCriteria(criteria?: CriteriaLike): Record<string, string>;\n    static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"../../../../langchain-core/dist/prompt_values.js\").BasePromptValueInterface, any>;\n    /**\n     * Create a new instance of the PairwiseStringEvalChain.\n     * @param llm\n     * @param criteria The criteria to use for evaluation.\n     * @param chainOptions Options to pass to the chain.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, criteria?: CriteriaLike, chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<PairwiseStringEvalChain>;\n    _prepareOutput(result: ChainValues): any;\n    _evaluateStringPairs(args: LLMPairwiseStringEvaluatorArgs, callOptions: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * A chain for comparing two outputs, such as the outputs\n * of two models, prompts, or outputs of a single model on similar inputs,\n * with labeled preferences.\n */\nexport declare class LabeledPairwiseStringEvalChain extends PairwiseStringEvalChain {\n    static lc_name(): string;\n    requiresReference: boolean;\n    static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"../../../../langchain-core/dist/prompt_values.js\").BasePromptValueInterface, any>;\n}\n"],"mappings":";;;;;;;;;;;;;;AAWqBc,cAAAA,gCAAAA,SAAyCb,mBAAT,CAA6BO,cAA7B,CAAA,CAAA;EAAA,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EAAA,YAA6BA,EAAAA,MAAAA,EAAAA;EAAc,WAGnEJ,CAAAA,WAAAA,EAAAA,UAAAA,EAAAA,GAAeD,cAAfC,EAAAA,EAAAA,UAAAA,EAA6CE,SAA7CF,GAAAA,SAAAA,CAAAA,EAAqEW,OAArEX,CAA6EI,cAA7EJ,CAAAA;;;;;;AAHoD,cAS5DY,uBAAAA,SAAgCN,0BAAAA,CAT4B;EAS5DM,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAuB,aAAA,CAAA,EAAA,MAAA;EAAA,cAO1BF,CAAAA,EAAAA,MAAAA;EAAgC,aACJD,EAAAA,OAAAA;EAAY,iBAAGI,EAAAA,OAAAA;EAAM,oBACzBZ,EAAAA,MAAAA;EAAkB,YAAA,EAF1CS,gCAE0C;EAA8G,OAA3GT,uBAAAA,CAAAA,QAAAA,CAAAA,EADjBQ,YACiBR,CAAAA,EADFY,MACEZ,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAkB,OAOzDL,qBAAAA,CAAAA,MAAAA,CAAAA,EAPkBK,kBAOlBL,CAAAA,EAPuCK,kBAOvCL,CAAAA,GAAAA,EAPoC,wBAAA,EAOpCA,GAAAA,CAAAA;EAA0B;;;;;;EAA2F,OAClHE,OAAAA,CAAAA,GAAAA,EADHF,0BACGE,EAAAA,QAAAA,CAAAA,EADoCW,YACpCX,EAAAA,YAAAA,CAAAA,EADiEmB,OACjEnB,CADyEkB,IACzElB,CAD8EO,iBAC9EP,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAD2Ga,OAC3Gb,CADmHc,uBACnHd,CAAAA;EAAW,cACPS,CAAAA,MAAAA,EADJT,WACIS,CAAAA,EAAAA,GAAAA;EAA8B,oBAAeC,CAAAA,IAAAA,EAA7CD,8BAA6CC,EAAAA,WAAAA,EAAAA,qBAAAA,CAAAA,IAAAA,CAAAA,KAAAA,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAA6CN,SAA7CM,GAAyDL,kBAAzDK,CAAAA,EAA8EG,OAA9EH,CAAsFV,WAAtFU,CAAAA;;;;;;AAlBG;AAyB1DU,cAAAA,8BAAAA,SAAuCN,uBAAAA,CAAT;EAAA,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EAAA,iBAGTX,EAAAA,OAAAA;EAAkB,OAAA,qBAAA,CAAA,MAAA,CAAA,EAAlBA,kBAAkB,CAAA,EAAGA,kBAAH,CAAA,GAAA,EAAA,wBAAA,EAAA,GAAA,CAAA"}
+{"version":3,"file":"pairwise.d.cts","names":["BaseLanguageModelInterface","BaseLLMOutputParser","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","EvalOutputType","LLMEvalChainInput","LLMPairwiseStringEvaluator","LLMPairwiseStringEvaluatorArgs","ExtractLLMCallOptions","CriteriaLike","PairwiseStringResultOutputParser","Promise","PairwiseStringEvalChain","Record","____________langchain_core_dist_prompt_values_js2","BasePromptValueInterface","Omit","Partial","LabeledPairwiseStringEvalChain"],"sources":["../../../src/evaluation/comparison/pairwise.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { EvalOutputType, LLMEvalChainInput, LLMPairwiseStringEvaluator, LLMPairwiseStringEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\nimport { CriteriaLike } from \"../criteria/criteria.js\";\n/**\n * A parser for the output of the PairwiseStringEvalChain.\n */\nexport declare class PairwiseStringResultOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\n/**\n * A chain for comparing two outputs, such as the outputs\n * of two models, prompts, or outputs of a single model on similar inputs.\n */\nexport declare class PairwiseStringEvalChain extends LLMPairwiseStringEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    skipReferenceWarning: string;\n    outputParser: PairwiseStringResultOutputParser;\n    static resolvePairwiseCriteria(criteria?: CriteriaLike): Record<string, string>;\n    static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"../../../../langchain-core/dist/prompt_values.js\").BasePromptValueInterface, any>;\n    /**\n     * Create a new instance of the PairwiseStringEvalChain.\n     * @param llm\n     * @param criteria The criteria to use for evaluation.\n     * @param chainOptions Options to pass to the chain.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, criteria?: CriteriaLike, chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<PairwiseStringEvalChain>;\n    _prepareOutput(result: ChainValues): any;\n    _evaluateStringPairs(args: LLMPairwiseStringEvaluatorArgs, callOptions: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * A chain for comparing two outputs, such as the outputs\n * of two models, prompts, or outputs of a single model on similar inputs,\n * with labeled preferences.\n */\nexport declare class LabeledPairwiseStringEvalChain extends PairwiseStringEvalChain {\n    static lc_name(): string;\n    requiresReference: boolean;\n    static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"../../../../langchain-core/dist/prompt_values.js\").BasePromptValueInterface, any>;\n}\n"],"mappings":";;;;;;;;;;;;;;AAWqBc,cAAAA,gCAAAA,SAAyCb,mBAAT,CAA6BO,cAA7B,CAAA,CAAA;EAAA,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EAAA,YAA6BA,EAAAA,MAAAA,EAAAA;EAAc,WAGnEJ,CAAAA,WAAAA,EAAAA,UAAAA,EAAAA,GAAeD,cAAfC,EAAAA,EAAAA,UAAAA,EAA6CE,SAA7CF,GAAAA,SAAAA,CAAAA,EAAqEW,OAArEX,CAA6EI,cAA7EJ,CAAAA;;;;;;AAHoD,cAS5DY,uBAAAA,SAAgCN,0BAAAA,CAT4B;EAS5DM,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAuB,aAAA,CAAA,EAAA,MAAA;EAAA,cAO1BF,CAAAA,EAAAA,MAAAA;EAAgC,aACJD,EAAAA,OAAAA;EAAY,iBAAGI,EAAAA,OAAAA;EAAM,oBACzBZ,EAAAA,MAAAA;EAAkB,YAAA,EAF1CS,gCAE0C;EAA8G,OAA3GT,uBAAAA,CAAAA,QAAAA,CAAAA,EADjBQ,YACiBR,CAAAA,EADFY,MACEZ,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAkB,OAOzDL,qBAAAA,CAAAA,MAAAA,CAAAA,EAPkBK,kBAOlBL,CAAAA,EAPuCK,kBAOvCL,CAAAA,GAAAA,EAPoC,wBAAA,EAOpCA,GAAAA,CAAAA;EAA0B;;;;;;EAA2F,OAClHE,OAAAA,CAAAA,GAAAA,EADHF,0BACGE,EAAAA,QAAAA,CAAAA,EADoCW,YACpCX,EAAAA,YAAAA,CAAAA,EADiEmB,OACjEnB,CADyEkB,IACzElB,CAD8EO,iBAC9EP,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAD2Ga,OAC3Gb,CADmHc,uBACnHd,CAAAA;EAAW,cACPS,CAAAA,MAAAA,EADJT,WACIS,CAAAA,EAAAA,GAAAA;EAA8B,oBAAeC,CAAAA,IAAAA,EAA7CD,8BAA6CC,EAAAA,WAAAA,EAAAA,qBAAAA,CAAAA,IAAAA,CAAAA,KAAAA,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAA6CN,SAA7CM,GAAyDL,kBAAzDK,CAAAA,EAA8EG,OAA9EH,CAAsFV,WAAtFU,CAAAA;;;;;;AAlBG;AAyB1DU,cAAAA,8BAAAA,SAAuCN,uBAAAA,CAAT;EAAA,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EAAA,iBAGTX,EAAAA,OAAAA;EAAkB,OAAA,qBAAA,CAAA,MAAA,CAAA,EAAlBA,kBAAkB,CAAA,EAAGA,kBAAH,CAAA,GAAA,EAAA,wBAAA,EAAA,GAAA,CAAA"}

package/dist/evaluation/criteria/criteria.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"criteria.d.cts","names":["BaseLanguageModelInterface","BaseLLMOutputParser","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","EvalOutputType","LLMEvalChainInput","LLMStringEvaluator","StringEvaluatorArgs","ExtractLLMCallOptions","ConstitutionalPrinciple","Criteria","CriteriaLike","CriteriaResultOutputParser","Promise","CriteriaEvalInput","CriteriaEvalChain","Record","____________langchain_core_dist_prompt_values_js2","BasePromptValueInterface","Omit","Partial","input","prediction","reference","LabeledCriteriaEvalChain"],"sources":["../../../src/evaluation/criteria/criteria.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { EvalOutputType, LLMEvalChainInput, LLMStringEvaluator, StringEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\nimport { ConstitutionalPrinciple } from \"../../chains/constitutional_ai/constitutional_principle.js\";\n/**\n * A Criteria to evaluate.\n */\nexport type Criteria = \"conciseness\" | \"relevance\" | \"correctness\" | \"coherence\" | \"harmfulness\" | \"maliciousness\" | \"helpfulness\" | \"controversiality\" | \"misogyny\" | \"criminality\" | \"insensitivity\" | \"depth\" | \"creativity\" | \"detail\";\nexport type CriteriaLike = {\n    [key: string]: string;\n} | Criteria | ConstitutionalPrinciple;\n/**\n * A parser for the output of the CriteriaEvalChain.\n */\nexport declare class CriteriaResultOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\nexport interface CriteriaEvalInput {\n    input?: string;\n    output: string;\n    reference?: string;\n}\nexport declare class CriteriaEvalChain extends LLMStringEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    skipReferenceWarning: string;\n    // The output parser to use for the evaluation chain.\n    outputParser: BaseLLMOutputParser<EvalOutputType>;\n    /**\n     * Resolve the criteria to evaluate.\n     * @param criteria The criteria to evaluate the runs against. It can be:\n     *                 -  a mapping of a criterion name to its description\n     *                 -  a single criterion name present in one of the default criteria\n     *                 -  a single `ConstitutionalPrinciple` instance\n     *\n     * @return A dictionary mapping criterion names to descriptions.\n     */\n    static resolveCriteria(criteria?: CriteriaLike): Record<string, string>;\n    /**\n     * Resolve the prompt to use for the evaluation.\n     * @param prompt\n     */\n    static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"../../../../langchain-core/dist/prompt_values.js\").BasePromptValueInterface, any>;\n    /**\n     * Create a new instance of the CriteriaEvalChain.\n     * @param llm\n     * @param criteria\n     * @param chainOptions Options to pass to the constructor of the LLMChain.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, criteria?: CriteriaLike, chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<CriteriaEvalChain>;\n    getEvalInput({ input, prediction, reference }: StringEvaluatorArgs): CriteriaEvalInput;\n    /**\n     * Prepare the output of the evaluation.\n     * @param result\n     */\n    _prepareOutput(result: ChainValues): any;\n    _evaluateStrings(args: StringEvaluatorArgs & ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Criteria evaluation chain that requires references.\n */\nexport declare class LabeledCriteriaEvalChain extends CriteriaEvalChain {\n    static lc_name(): string;\n    // Whether the evaluation requires a reference text.\n    requiresReference: boolean;\n    static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"../../../../langchain-core/dist/prompt_values.js\").BasePromptValueInterface, any>;\n}\n"],"mappings":";;;;;;;;;;;;;;AAWYc,KAAAA,QAAAA,GAAQ,aAAA,GAAA,WAAA,GAAA,aAAA,GAAA,WAAA,GAAA,aAAA,GAAA,eAAA,GAAA,aAAA,GAAA,kBAAA,GAAA,UAAA,GAAA,aAAA,GAAA,eAAA,GAAA,OAAA,GAAA,YAAA,GAAA,QAAA;AACRC,KAAAA,YAAAA,GAAY;EAAA,CAAA,GAAA,EAAA,MAAA,CAAA,EAAA,MAAA;CAAA,GAEpBD,QAAAA,GAAWD,uBAAXC;;AAAkC;AAItC;AAA+C,cAA1BE,0BAAAA,SAAmCf,mBAAT,CAA6BO,cAA7B,CAAA,CAAA;EAAA,YAA6BA,EAAAA,MAAAA,EAAAA;EAAc,WAE7DJ,CAAAA,WAAAA,EAAAA,UAAAA,EAAAA,GAAeD,cAAfC,EAAAA,EAAAA,UAAAA,EAA6CE,SAA7CF,GAAAA,SAAAA,CAAAA,EAAqEa,OAArEb,CAA6EI,cAA7EJ,CAAAA;;AAA6CE,UAEzDY,iBAAAA,CAFyDZ;EAAS,KAAuBE,CAAAA,EAAAA,MAAAA;EAAc,MAAtBS,EAAAA,MAAAA;EAAO,SAFjDhB,CAAAA,EAAAA,MAAAA;AAAmB;AAI1DiB,cAKIC,iBAAAA,SAA0BT,kBAAAA,CALb;EAKbS,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAiB;EAAA,aAAA,CAAA,EAAA,MAAA;EAAA,cAQAX,CAAAA,EAAAA,MAAAA;EAAc,aAAlCP,EAAAA,OAAAA;EAAmB,iBAUCc,EAAAA,OAAAA;EAAY,oBAAGK,EAAAA,MAAAA;EAAM;EAKP,YAAA,EAflCnB,mBAekC,CAfdO,cAec,CAAA;EAA8G;;;;;;;;;EAQ1I,OAAEkB,eAAAA,CAAAA,QAAAA,CAAAA,EAbYX,YAaZW,CAAAA,EAb2BN,MAa3BM,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAU;;;;EAKE,OACXf,aAAAA,CAAAA,MAAAA,CAAAA,EAdON,kBAcPM,CAAAA,EAd4BN,kBAc5BM,CAAAA,GAAAA,EAdyB,wBAAA,EAczBA,GAAAA,CAAAA;EAAmB;;;;;;EArCmB,OAAA,OAAA,CAAA,GAAA,EA8BzCX,0BA9ByC,EAAA,QAAA,CAAA,EA8BFe,YA9BE,EAAA,YAAA,CAAA,EA8B2BS,OA9B3B,CA8BmCD,IA9BnC,CA8BwCd,iBA9BxC,EAAA,KAAA,CAAA,CAAA,CAAA,EA8BqEQ,OA9BrE,CA8B6EE,iBA9B7E,CAAA;EA0C5CS,YAAAA,CAAAA;IAAAA,KAAAA;IAAAA,UAAwB;IAAA;EAAA,CAAA,EAXMjB,mBAWN,CAAA,EAX4BO,iBAW5B;EAAA;;;;EAI4B,cAJnBC,CAAAA,MAAAA,EAN3BjB,WAM2BiB,CAAAA,EAAAA,GAAAA;EAAiB,gBAAA,CAAA,IAAA,EAL5CR,mBAK4C,GALtBC,qBAKsB,CAAA,IAAA,CAAA,KAAA,CAAA,CAAA,EAAA,MAAA,CAAA,EALuBN,SAKvB,GALmCC,kBAKnC,CAAA,EALwDU,OAKxD,CALgEf,WAKhE,CAAA;;;;;cAAlD0B,wBAAAA,SAAiCT,iBAAAA;;;;gCAIpBd,qBAAqBA,wBAAH,wBAAA"}
+{"version":3,"file":"criteria.d.cts","names":["BaseLanguageModelInterface","BaseLLMOutputParser","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","EvalOutputType","LLMEvalChainInput","LLMStringEvaluator","StringEvaluatorArgs","ExtractLLMCallOptions","ConstitutionalPrinciple","Criteria","CriteriaLike","CriteriaResultOutputParser","Promise","CriteriaEvalInput","CriteriaEvalChain","Record","____________langchain_core_dist_prompt_values_js0","BasePromptValueInterface","Omit","Partial","input","prediction","reference","LabeledCriteriaEvalChain"],"sources":["../../../src/evaluation/criteria/criteria.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { EvalOutputType, LLMEvalChainInput, LLMStringEvaluator, StringEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\nimport { ConstitutionalPrinciple } from \"../../chains/constitutional_ai/constitutional_principle.js\";\n/**\n * A Criteria to evaluate.\n */\nexport type Criteria = \"conciseness\" | \"relevance\" | \"correctness\" | \"coherence\" | \"harmfulness\" | \"maliciousness\" | \"helpfulness\" | \"controversiality\" | \"misogyny\" | \"criminality\" | \"insensitivity\" | \"depth\" | \"creativity\" | \"detail\";\nexport type CriteriaLike = {\n    [key: string]: string;\n} | Criteria | ConstitutionalPrinciple;\n/**\n * A parser for the output of the CriteriaEvalChain.\n */\nexport declare class CriteriaResultOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\nexport interface CriteriaEvalInput {\n    input?: string;\n    output: string;\n    reference?: string;\n}\nexport declare class CriteriaEvalChain extends LLMStringEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    skipReferenceWarning: string;\n    // The output parser to use for the evaluation chain.\n    outputParser: BaseLLMOutputParser<EvalOutputType>;\n    /**\n     * Resolve the criteria to evaluate.\n     * @param criteria The criteria to evaluate the runs against. It can be:\n     *                 -  a mapping of a criterion name to its description\n     *                 -  a single criterion name present in one of the default criteria\n     *                 -  a single `ConstitutionalPrinciple` instance\n     *\n     * @return A dictionary mapping criterion names to descriptions.\n     */\n    static resolveCriteria(criteria?: CriteriaLike): Record<string, string>;\n    /**\n     * Resolve the prompt to use for the evaluation.\n     * @param prompt\n     */\n    static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"../../../../langchain-core/dist/prompt_values.js\").BasePromptValueInterface, any>;\n    /**\n     * Create a new instance of the CriteriaEvalChain.\n     * @param llm\n     * @param criteria\n     * @param chainOptions Options to pass to the constructor of the LLMChain.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, criteria?: CriteriaLike, chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<CriteriaEvalChain>;\n    getEvalInput({ input, prediction, reference }: StringEvaluatorArgs): CriteriaEvalInput;\n    /**\n     * Prepare the output of the evaluation.\n     * @param result\n     */\n    _prepareOutput(result: ChainValues): any;\n    _evaluateStrings(args: StringEvaluatorArgs & ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Criteria evaluation chain that requires references.\n */\nexport declare class LabeledCriteriaEvalChain extends CriteriaEvalChain {\n    static lc_name(): string;\n    // Whether the evaluation requires a reference text.\n    requiresReference: boolean;\n    static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"../../../../langchain-core/dist/prompt_values.js\").BasePromptValueInterface, any>;\n}\n"],"mappings":";;;;;;;;;;;;;;AAWYc,KAAAA,QAAAA,GAAQ,aAAA,GAAA,WAAA,GAAA,aAAA,GAAA,WAAA,GAAA,aAAA,GAAA,eAAA,GAAA,aAAA,GAAA,kBAAA,GAAA,UAAA,GAAA,aAAA,GAAA,eAAA,GAAA,OAAA,GAAA,YAAA,GAAA,QAAA;AACRC,KAAAA,YAAAA,GAAY;EAAA,CAAA,GAAA,EAAA,MAAA,CAAA,EAAA,MAAA;CAAA,GAEpBD,QAAAA,GAAWD,uBAAXC;;AAAkC;AAItC;AAA+C,cAA1BE,0BAAAA,SAAmCf,mBAAT,CAA6BO,cAA7B,CAAA,CAAA;EAAA,YAA6BA,EAAAA,MAAAA,EAAAA;EAAc,WAE7DJ,CAAAA,WAAAA,EAAAA,UAAAA,EAAAA,GAAeD,cAAfC,EAAAA,EAAAA,UAAAA,EAA6CE,SAA7CF,GAAAA,SAAAA,CAAAA,EAAqEa,OAArEb,CAA6EI,cAA7EJ,CAAAA;;AAA6CE,UAEzDY,iBAAAA,CAFyDZ;EAAS,KAAuBE,CAAAA,EAAAA,MAAAA;EAAc,MAAtBS,EAAAA,MAAAA;EAAO,SAFjDhB,CAAAA,EAAAA,MAAAA;AAAmB;AAI1DiB,cAKIC,iBAAAA,SAA0BT,kBAAAA,CALb;EAKbS,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAiB;EAAA,aAAA,CAAA,EAAA,MAAA;EAAA,cAQAX,CAAAA,EAAAA,MAAAA;EAAc,aAAlCP,EAAAA,OAAAA;EAAmB,iBAUCc,EAAAA,OAAAA;EAAY,oBAAGK,EAAAA,MAAAA;EAAM;EAKP,YAAA,EAflCnB,mBAekC,CAfdO,cAec,CAAA;EAA8G;;;;;;;;;EAQ1I,OAAEkB,eAAAA,CAAAA,QAAAA,CAAAA,EAbYX,YAaZW,CAAAA,EAb2BN,MAa3BM,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAU;;;;EAKE,OACXf,aAAAA,CAAAA,MAAAA,CAAAA,EAdON,kBAcPM,CAAAA,EAd4BN,kBAc5BM,CAAAA,GAAAA,EAdyB,wBAAA,EAczBA,GAAAA,CAAAA;EAAmB;;;;;;EArCmB,OAAA,OAAA,CAAA,GAAA,EA8BzCX,0BA9ByC,EAAA,QAAA,CAAA,EA8BFe,YA9BE,EAAA,YAAA,CAAA,EA8B2BS,OA9B3B,CA8BmCD,IA9BnC,CA8BwCd,iBA9BxC,EAAA,KAAA,CAAA,CAAA,CAAA,EA8BqEQ,OA9BrE,CA8B6EE,iBA9B7E,CAAA;EA0C5CS,YAAAA,CAAAA;IAAAA,KAAAA;IAAAA,UAAwB;IAAA;EAAA,CAAA,EAXMjB,mBAWN,CAAA,EAX4BO,iBAW5B;EAAA;;;;EAI4B,cAJnBC,CAAAA,MAAAA,EAN3BjB,WAM2BiB,CAAAA,EAAAA,GAAAA;EAAiB,gBAAA,CAAA,IAAA,EAL5CR,mBAK4C,GALtBC,qBAKsB,CAAA,IAAA,CAAA,KAAA,CAAA,CAAA,EAAA,MAAA,CAAA,EALuBN,SAKvB,GALmCC,kBAKnC,CAAA,EALwDU,OAKxD,CALgEf,WAKhE,CAAA;;;;;cAAlD0B,wBAAAA,SAAiCT,iBAAAA;;;;gCAIpBd,qBAAqBA,wBAAH,wBAAA"}

package/dist/evaluation/embedding_distance/base.cjs

@@ -1,9 +1,7 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
 const require_base = require('../base.cjs');
 const require_similarities = require('../../util/ml-distance/similarities.cjs');
 const require_distances = require('../../util/ml-distance/distances.cjs');
 const require_euclidean = require('../../util/ml-distance-euclidean/euclidean.cjs');
-const __langchain_openai = require_rolldown_runtime.__toESM(require("@langchain/openai"));
 
 //#region src/evaluation/embedding_distance/base.ts
 /**
@@ -42,7 +40,7 @@ var EmbeddingDistanceEvalChain = class extends require_base.StringEvaluator {
 	distanceMetric = "cosine";
 	constructor(fields) {
 		super();
-		this.embedding = fields?.embedding || new __langchain_openai.OpenAIEmbeddings();
+		this.embedding = fields?.embedding;
 		this.distanceMetric = fields?.distanceMetric || "cosine";
 	}
 	_chainType() {
@@ -77,7 +75,7 @@ var PairwiseEmbeddingDistanceEvalChain = class extends require_base.PairwiseStri
 	distanceMetric = "cosine";
 	constructor(fields) {
 		super();
-		this.embedding = fields?.embedding || new __langchain_openai.OpenAIEmbeddings();
+		this.embedding = fields?.embedding;
 		this.distanceMetric = fields?.distanceMetric || "cosine";
 	}
 	_chainType() {

package/dist/evaluation/embedding_distance/base.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"base.cjs","names":["distanceType: EmbeddingDistanceType","distanceFunctions: { [key in EmbeddingDistanceType]: VectorFunction }","X: number[]","Y: number[]","cosine","vectors: number[][]","distanceMetric: EmbeddingDistanceType","StringEvaluator","fields: EmbeddingDistanceEvalChainInput","OpenAIEmbeddings","args: StringEvaluatorArgs","config: Callbacks | BaseCallbackConfig | undefined","values: ChainValues","_runManager: CallbackManagerForChainRun | undefined","PairwiseStringEvaluator","args: PairwiseStringEvaluatorArgs","config?: Callbacks | BaseCallbackConfig"],"sources":["../../../src/evaluation/embedding_distance/base.ts"],"sourcesContent":["import type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { OpenAIEmbeddings } from \"@langchain/openai\";\nimport {\n  CallbackManagerForChainRun,\n  Callbacks,\n  BaseCallbackConfig,\n} from \"@langchain/core/callbacks/manager\";\nimport {\n  PairwiseStringEvaluator,\n  PairwiseStringEvaluatorArgs,\n  StringEvaluator,\n  StringEvaluatorArgs,\n} from \"../base.js\";\nimport { cosine } from \"../../util/ml-distance/similarities.js\";\nimport { chebyshev, manhattan } from \"../../util/ml-distance/distances.js\";\nimport { euclidean } from \"../../util/ml-distance-euclidean/euclidean.js\";\n\n/**\n *\n * Embedding Distance Metric.\n *\n * COSINE: Cosine distance metric.\n * EUCLIDEAN: Euclidean distance metric.\n * MANHATTAN: Manhattan distance metric.\n * CHEBYSHEV: Chebyshev distance metric.\n * HAMMING: Hamming distance metric.\n */\nexport type EmbeddingDistanceType =\n  | \"cosine\"\n  | \"euclidean\"\n  | \"manhattan\"\n  | \"chebyshev\";\n\n/**\n * Embedding Distance Evaluation Chain Input.\n */\nexport interface EmbeddingDistanceEvalChainInput {\n  /**\n   * The embedding objects to vectorize the outputs.\n   */\n  embedding?: EmbeddingsInterface;\n\n  /**\n   * The distance metric to use\n   * for comparing the embeddings.\n   */\n  distanceMetric?: EmbeddingDistanceType;\n}\n\ntype VectorFunction = (xVector: number[], yVector: number[]) => number;\n\n/**\n * Get the distance function for the given distance type.\n * @param distance The distance type.\n * @return The distance function.\n */\nexport function getDistanceCalculationFunction(\n  distanceType: EmbeddingDistanceType\n): VectorFunction {\n  const distanceFunctions: { [key in EmbeddingDistanceType]: VectorFunction } =\n    {\n      cosine: (X: number[], Y: number[]) => 1.0 - cosine(X, Y),\n      euclidean,\n      manhattan,\n      chebyshev,\n    };\n\n  return distanceFunctions[distanceType];\n}\n\n/**\n * Compute the score based on the distance metric.\n * @param vectors The input vectors.\n * @param distanceMetric The distance metric.\n * @return The computed score.\n */\nexport function computeEvaluationScore(\n  vectors: number[][],\n  distanceMetric: EmbeddingDistanceType\n): number {\n  const metricFunction = getDistanceCalculationFunction(distanceMetric);\n  return metricFunction(vectors[0], vectors[1]);\n}\n\n/**\n * Use embedding distances to score semantic difference between\n * a prediction and reference.\n */\nexport class EmbeddingDistanceEvalChain\n  extends StringEvaluator\n  implements EmbeddingDistanceEvalChainInput\n{\n  requiresReference = true;\n\n  requiresInput = false;\n\n  outputKey = \"score\";\n\n  embedding?: EmbeddingsInterface;\n\n  distanceMetric: EmbeddingDistanceType = \"cosine\";\n\n  constructor(fields: EmbeddingDistanceEvalChainInput) {\n    super();\n    this.embedding = fields?.embedding || new OpenAIEmbeddings();\n    this.distanceMetric = fields?.distanceMetric || \"cosine\";\n  }\n\n  _chainType() {\n    return `embedding_${this.distanceMetric}_distance` as const;\n  }\n\n  async _evaluateStrings(\n    args: StringEvaluatorArgs,\n    config: Callbacks | BaseCallbackConfig | undefined\n  ): Promise<ChainValues> {\n    const result = await this.call(args, config);\n\n    return { [this.outputKey]: result[this.outputKey] };\n  }\n\n  get inputKeys(): string[] {\n    return [\"reference\", \"prediction\"];\n  }\n\n  get outputKeys(): string[] {\n    return [this.outputKey];\n  }\n\n  async _call(\n    values: ChainValues,\n    _runManager: CallbackManagerForChainRun | undefined\n  ): Promise<ChainValues> {\n    const { prediction, reference } = values;\n\n    if (!this.embedding) throw new Error(\"Embedding is undefined\");\n\n    const vectors = await this.embedding.embedDocuments([\n      prediction,\n      reference,\n    ]);\n\n    const score = computeEvaluationScore(vectors, this.distanceMetric);\n\n    return { [this.outputKey]: score };\n  }\n}\n\n/**\n * Use embedding distances to score semantic difference between two predictions.\n */\nexport class PairwiseEmbeddingDistanceEvalChain\n  extends PairwiseStringEvaluator\n  implements EmbeddingDistanceEvalChainInput\n{\n  requiresReference = false;\n\n  requiresInput = false;\n\n  outputKey = \"score\";\n\n  embedding?: EmbeddingsInterface;\n\n  distanceMetric: EmbeddingDistanceType = \"cosine\";\n\n  constructor(fields: EmbeddingDistanceEvalChainInput) {\n    super();\n    this.embedding = fields?.embedding || new OpenAIEmbeddings();\n    this.distanceMetric = fields?.distanceMetric || \"cosine\";\n  }\n\n  _chainType() {\n    return `pairwise_embedding_${this.distanceMetric}_distance` as const;\n  }\n\n  async _evaluateStringPairs(\n    args: PairwiseStringEvaluatorArgs,\n    config?: Callbacks | BaseCallbackConfig\n  ): Promise<ChainValues> {\n    const result = await this.call(args, config);\n\n    return { [this.outputKey]: result[this.outputKey] };\n  }\n\n  get inputKeys(): string[] {\n    return [\"prediction\", \"predictionB\"];\n  }\n\n  get outputKeys(): string[] {\n    return [this.outputKey];\n  }\n\n  async _call(\n    values: ChainValues,\n    _runManager: CallbackManagerForChainRun | undefined\n  ): Promise<ChainValues> {\n    const { prediction, predictionB } = values;\n\n    if (!this.embedding) throw new Error(\"Embedding is undefined\");\n\n    const vectors = await this.embedding.embedDocuments([\n      prediction,\n      predictionB,\n    ]);\n\n    const score = computeEvaluationScore(vectors, this.distanceMetric);\n\n    return { [this.outputKey]: score };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAyDA,SAAgB,+BACdA,cACgB;CAChB,MAAMC,oBACJ;EACE,QAAQ,CAACC,GAAaC,MAAgB,IAAMC,4BAAO,GAAG,EAAE;EACxD;EACA;EACA;CACD;AAEH,QAAO,kBAAkB;AAC1B;;;;;;;AAQD,SAAgB,uBACdC,SACAC,gBACQ;CACR,MAAM,iBAAiB,+BAA+B,eAAe;AACrE,QAAO,eAAe,QAAQ,IAAI,QAAQ,GAAG;AAC9C;;;;;AAMD,IAAa,6BAAb,cACUC,6BAEV;CACE,oBAAoB;CAEpB,gBAAgB;CAEhB,YAAY;CAEZ;CAEA,iBAAwC;CAExC,YAAYC,QAAyC;EACnD,OAAO;EACP,KAAK,YAAY,QAAQ,aAAa,IAAIC;EAC1C,KAAK,iBAAiB,QAAQ,kBAAkB;CACjD;CAED,aAAa;AACX,SAAO,CAAC,UAAU,EAAE,KAAK,eAAe,SAAS,CAAC;CACnD;CAED,MAAM,iBACJC,MACAC,QACsB;EACtB,MAAM,SAAS,MAAM,KAAK,KAAK,MAAM,OAAO;AAE5C,SAAO,GAAG,KAAK,YAAY,OAAO,KAAK,WAAY;CACpD;CAED,IAAI,YAAsB;AACxB,SAAO,CAAC,aAAa,YAAa;CACnC;CAED,IAAI,aAAuB;AACzB,SAAO,CAAC,KAAK,SAAU;CACxB;CAED,MAAM,MACJC,QACAC,aACsB;EACtB,MAAM,EAAE,YAAY,WAAW,GAAG;AAElC,MAAI,CAAC,KAAK,UAAW,OAAM,IAAI,MAAM;EAErC,MAAM,UAAU,MAAM,KAAK,UAAU,eAAe,CAClD,YACA,SACD,EAAC;EAEF,MAAM,QAAQ,uBAAuB,SAAS,KAAK,eAAe;AAElE,SAAO,GAAG,KAAK,YAAY,MAAO;CACnC;AACF;;;;AAKD,IAAa,qCAAb,cACUC,qCAEV;CACE,oBAAoB;CAEpB,gBAAgB;CAEhB,YAAY;CAEZ;CAEA,iBAAwC;CAExC,YAAYN,QAAyC;EACnD,OAAO;EACP,KAAK,YAAY,QAAQ,aAAa,IAAIC;EAC1C,KAAK,iBAAiB,QAAQ,kBAAkB;CACjD;CAED,aAAa;AACX,SAAO,CAAC,mBAAmB,EAAE,KAAK,eAAe,SAAS,CAAC;CAC5D;CAED,MAAM,qBACJM,MACAC,QACsB;EACtB,MAAM,SAAS,MAAM,KAAK,KAAK,MAAM,OAAO;AAE5C,SAAO,GAAG,KAAK,YAAY,OAAO,KAAK,WAAY;CACpD;CAED,IAAI,YAAsB;AACxB,SAAO,CAAC,cAAc,aAAc;CACrC;CAED,IAAI,aAAuB;AACzB,SAAO,CAAC,KAAK,SAAU;CACxB;CAED,MAAM,MACJJ,QACAC,aACsB;EACtB,MAAM,EAAE,YAAY,aAAa,GAAG;AAEpC,MAAI,CAAC,KAAK,UAAW,OAAM,IAAI,MAAM;EAErC,MAAM,UAAU,MAAM,KAAK,UAAU,eAAe,CAClD,YACA,WACD,EAAC;EAEF,MAAM,QAAQ,uBAAuB,SAAS,KAAK,eAAe;AAElE,SAAO,GAAG,KAAK,YAAY,MAAO;CACnC;AACF"}
+{"version":3,"file":"base.cjs","names":["distanceType: EmbeddingDistanceType","distanceFunctions: { [key in EmbeddingDistanceType]: VectorFunction }","X: number[]","Y: number[]","cosine","vectors: number[][]","distanceMetric: EmbeddingDistanceType","StringEvaluator","fields: EmbeddingDistanceEvalChainInput","args: StringEvaluatorArgs","config: Callbacks | BaseCallbackConfig | undefined","values: ChainValues","_runManager: CallbackManagerForChainRun | undefined","PairwiseStringEvaluator","args: PairwiseStringEvaluatorArgs","config?: Callbacks | BaseCallbackConfig"],"sources":["../../../src/evaluation/embedding_distance/base.ts"],"sourcesContent":["import type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport {\n  CallbackManagerForChainRun,\n  Callbacks,\n  BaseCallbackConfig,\n} from \"@langchain/core/callbacks/manager\";\nimport {\n  PairwiseStringEvaluator,\n  PairwiseStringEvaluatorArgs,\n  StringEvaluator,\n  StringEvaluatorArgs,\n} from \"../base.js\";\nimport { cosine } from \"../../util/ml-distance/similarities.js\";\nimport { chebyshev, manhattan } from \"../../util/ml-distance/distances.js\";\nimport { euclidean } from \"../../util/ml-distance-euclidean/euclidean.js\";\n\n/**\n *\n * Embedding Distance Metric.\n *\n * COSINE: Cosine distance metric.\n * EUCLIDEAN: Euclidean distance metric.\n * MANHATTAN: Manhattan distance metric.\n * CHEBYSHEV: Chebyshev distance metric.\n * HAMMING: Hamming distance metric.\n */\nexport type EmbeddingDistanceType =\n  | \"cosine\"\n  | \"euclidean\"\n  | \"manhattan\"\n  | \"chebyshev\";\n\n/**\n * Embedding Distance Evaluation Chain Input.\n */\nexport interface EmbeddingDistanceEvalChainInput {\n  /**\n   * The embedding objects to vectorize the outputs.\n   */\n  embedding?: EmbeddingsInterface;\n\n  /**\n   * The distance metric to use\n   * for comparing the embeddings.\n   */\n  distanceMetric?: EmbeddingDistanceType;\n}\n\ntype VectorFunction = (xVector: number[], yVector: number[]) => number;\n\n/**\n * Get the distance function for the given distance type.\n * @param distance The distance type.\n * @return The distance function.\n */\nexport function getDistanceCalculationFunction(\n  distanceType: EmbeddingDistanceType\n): VectorFunction {\n  const distanceFunctions: { [key in EmbeddingDistanceType]: VectorFunction } =\n    {\n      cosine: (X: number[], Y: number[]) => 1.0 - cosine(X, Y),\n      euclidean,\n      manhattan,\n      chebyshev,\n    };\n\n  return distanceFunctions[distanceType];\n}\n\n/**\n * Compute the score based on the distance metric.\n * @param vectors The input vectors.\n * @param distanceMetric The distance metric.\n * @return The computed score.\n */\nexport function computeEvaluationScore(\n  vectors: number[][],\n  distanceMetric: EmbeddingDistanceType\n): number {\n  const metricFunction = getDistanceCalculationFunction(distanceMetric);\n  return metricFunction(vectors[0], vectors[1]);\n}\n\n/**\n * Use embedding distances to score semantic difference between\n * a prediction and reference.\n */\nexport class EmbeddingDistanceEvalChain\n  extends StringEvaluator\n  implements EmbeddingDistanceEvalChainInput\n{\n  requiresReference = true;\n\n  requiresInput = false;\n\n  outputKey = \"score\";\n\n  embedding?: EmbeddingsInterface;\n\n  distanceMetric: EmbeddingDistanceType = \"cosine\";\n\n  constructor(fields: EmbeddingDistanceEvalChainInput) {\n    super();\n    this.embedding = fields?.embedding;\n    this.distanceMetric = fields?.distanceMetric || \"cosine\";\n  }\n\n  _chainType() {\n    return `embedding_${this.distanceMetric}_distance` as const;\n  }\n\n  async _evaluateStrings(\n    args: StringEvaluatorArgs,\n    config: Callbacks | BaseCallbackConfig | undefined\n  ): Promise<ChainValues> {\n    const result = await this.call(args, config);\n\n    return { [this.outputKey]: result[this.outputKey] };\n  }\n\n  get inputKeys(): string[] {\n    return [\"reference\", \"prediction\"];\n  }\n\n  get outputKeys(): string[] {\n    return [this.outputKey];\n  }\n\n  async _call(\n    values: ChainValues,\n    _runManager: CallbackManagerForChainRun | undefined\n  ): Promise<ChainValues> {\n    const { prediction, reference } = values;\n\n    if (!this.embedding) throw new Error(\"Embedding is undefined\");\n\n    const vectors = await this.embedding.embedDocuments([\n      prediction,\n      reference,\n    ]);\n\n    const score = computeEvaluationScore(vectors, this.distanceMetric);\n\n    return { [this.outputKey]: score };\n  }\n}\n\n/**\n * Use embedding distances to score semantic difference between two predictions.\n */\nexport class PairwiseEmbeddingDistanceEvalChain\n  extends PairwiseStringEvaluator\n  implements EmbeddingDistanceEvalChainInput\n{\n  requiresReference = false;\n\n  requiresInput = false;\n\n  outputKey = \"score\";\n\n  embedding?: EmbeddingsInterface;\n\n  distanceMetric: EmbeddingDistanceType = \"cosine\";\n\n  constructor(fields: EmbeddingDistanceEvalChainInput) {\n    super();\n    this.embedding = fields?.embedding;\n    this.distanceMetric = fields?.distanceMetric || \"cosine\";\n  }\n\n  _chainType() {\n    return `pairwise_embedding_${this.distanceMetric}_distance` as const;\n  }\n\n  async _evaluateStringPairs(\n    args: PairwiseStringEvaluatorArgs,\n    config?: Callbacks | BaseCallbackConfig\n  ): Promise<ChainValues> {\n    const result = await this.call(args, config);\n\n    return { [this.outputKey]: result[this.outputKey] };\n  }\n\n  get inputKeys(): string[] {\n    return [\"prediction\", \"predictionB\"];\n  }\n\n  get outputKeys(): string[] {\n    return [this.outputKey];\n  }\n\n  async _call(\n    values: ChainValues,\n    _runManager: CallbackManagerForChainRun | undefined\n  ): Promise<ChainValues> {\n    const { prediction, predictionB } = values;\n\n    if (!this.embedding) throw new Error(\"Embedding is undefined\");\n\n    const vectors = await this.embedding.embedDocuments([\n      prediction,\n      predictionB,\n    ]);\n\n    const score = computeEvaluationScore(vectors, this.distanceMetric);\n\n    return { [this.outputKey]: score };\n  }\n}\n"],"mappings":";;;;;;;;;;;AAwDA,SAAgB,+BACdA,cACgB;CAChB,MAAMC,oBACJ;EACE,QAAQ,CAACC,GAAaC,MAAgB,IAAMC,4BAAO,GAAG,EAAE;EACxD;EACA;EACA;CACD;AAEH,QAAO,kBAAkB;AAC1B;;;;;;;AAQD,SAAgB,uBACdC,SACAC,gBACQ;CACR,MAAM,iBAAiB,+BAA+B,eAAe;AACrE,QAAO,eAAe,QAAQ,IAAI,QAAQ,GAAG;AAC9C;;;;;AAMD,IAAa,6BAAb,cACUC,6BAEV;CACE,oBAAoB;CAEpB,gBAAgB;CAEhB,YAAY;CAEZ;CAEA,iBAAwC;CAExC,YAAYC,QAAyC;EACnD,OAAO;EACP,KAAK,YAAY,QAAQ;EACzB,KAAK,iBAAiB,QAAQ,kBAAkB;CACjD;CAED,aAAa;AACX,SAAO,CAAC,UAAU,EAAE,KAAK,eAAe,SAAS,CAAC;CACnD;CAED,MAAM,iBACJC,MACAC,QACsB;EACtB,MAAM,SAAS,MAAM,KAAK,KAAK,MAAM,OAAO;AAE5C,SAAO,GAAG,KAAK,YAAY,OAAO,KAAK,WAAY;CACpD;CAED,IAAI,YAAsB;AACxB,SAAO,CAAC,aAAa,YAAa;CACnC;CAED,IAAI,aAAuB;AACzB,SAAO,CAAC,KAAK,SAAU;CACxB;CAED,MAAM,MACJC,QACAC,aACsB;EACtB,MAAM,EAAE,YAAY,WAAW,GAAG;AAElC,MAAI,CAAC,KAAK,UAAW,OAAM,IAAI,MAAM;EAErC,MAAM,UAAU,MAAM,KAAK,UAAU,eAAe,CAClD,YACA,SACD,EAAC;EAEF,MAAM,QAAQ,uBAAuB,SAAS,KAAK,eAAe;AAElE,SAAO,GAAG,KAAK,YAAY,MAAO;CACnC;AACF;;;;AAKD,IAAa,qCAAb,cACUC,qCAEV;CACE,oBAAoB;CAEpB,gBAAgB;CAEhB,YAAY;CAEZ;CAEA,iBAAwC;CAExC,YAAYL,QAAyC;EACnD,OAAO;EACP,KAAK,YAAY,QAAQ;EACzB,KAAK,iBAAiB,QAAQ,kBAAkB;CACjD;CAED,aAAa;AACX,SAAO,CAAC,mBAAmB,EAAE,KAAK,eAAe,SAAS,CAAC;CAC5D;CAED,MAAM,qBACJM,MACAC,QACsB;EACtB,MAAM,SAAS,MAAM,KAAK,KAAK,MAAM,OAAO;AAE5C,SAAO,GAAG,KAAK,YAAY,OAAO,KAAK,WAAY;CACpD;CAED,IAAI,YAAsB;AACxB,SAAO,CAAC,cAAc,aAAc;CACrC;CAED,IAAI,aAAuB;AACzB,SAAO,CAAC,KAAK,SAAU;CACxB;CAED,MAAM,MACJJ,QACAC,aACsB;EACtB,MAAM,EAAE,YAAY,aAAa,GAAG;AAEpC,MAAI,CAAC,KAAK,UAAW,OAAM,IAAI,MAAM;EAErC,MAAM,UAAU,MAAM,KAAK,UAAU,eAAe,CAClD,YACA,WACD,EAAC;EAEF,MAAM,QAAQ,uBAAuB,SAAS,KAAK,eAAe;AAElE,SAAO,GAAG,KAAK,YAAY,MAAO;CACnC;AACF"}

package/dist/evaluation/embedding_distance/base.js

@@ -2,7 +2,6 @@ import { PairwiseStringEvaluator, StringEvaluator } from "../base.js";
 import { cosine } from "../../util/ml-distance/similarities.js";
 import { chebyshev, manhattan } from "../../util/ml-distance/distances.js";
 import { euclidean } from "../../util/ml-distance-euclidean/euclidean.js";
-import { OpenAIEmbeddings } from "@langchain/openai";
 
 //#region src/evaluation/embedding_distance/base.ts
 /**
@@ -41,7 +40,7 @@ var EmbeddingDistanceEvalChain = class extends StringEvaluator {
 	distanceMetric = "cosine";
 	constructor(fields) {
 		super();
-		this.embedding = fields?.embedding || new OpenAIEmbeddings();
+		this.embedding = fields?.embedding;
 		this.distanceMetric = fields?.distanceMetric || "cosine";
 	}
 	_chainType() {
@@ -76,7 +75,7 @@ var PairwiseEmbeddingDistanceEvalChain = class extends PairwiseStringEvaluator {
 	distanceMetric = "cosine";
 	constructor(fields) {
 		super();
-		this.embedding = fields?.embedding || new OpenAIEmbeddings();
+		this.embedding = fields?.embedding;
 		this.distanceMetric = fields?.distanceMetric || "cosine";
 	}
 	_chainType() {

package/dist/evaluation/embedding_distance/base.js.map

@@ -1 +1 @@
-{"version":3,"file":"base.js","names":["distanceType: EmbeddingDistanceType","distanceFunctions: { [key in EmbeddingDistanceType]: VectorFunction }","X: number[]","Y: number[]","vectors: number[][]","distanceMetric: EmbeddingDistanceType","fields: EmbeddingDistanceEvalChainInput","args: StringEvaluatorArgs","config: Callbacks | BaseCallbackConfig | undefined","values: ChainValues","_runManager: CallbackManagerForChainRun | undefined","args: PairwiseStringEvaluatorArgs","config?: Callbacks | BaseCallbackConfig"],"sources":["../../../src/evaluation/embedding_distance/base.ts"],"sourcesContent":["import type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { OpenAIEmbeddings } from \"@langchain/openai\";\nimport {\n  CallbackManagerForChainRun,\n  Callbacks,\n  BaseCallbackConfig,\n} from \"@langchain/core/callbacks/manager\";\nimport {\n  PairwiseStringEvaluator,\n  PairwiseStringEvaluatorArgs,\n  StringEvaluator,\n  StringEvaluatorArgs,\n} from \"../base.js\";\nimport { cosine } from \"../../util/ml-distance/similarities.js\";\nimport { chebyshev, manhattan } from \"../../util/ml-distance/distances.js\";\nimport { euclidean } from \"../../util/ml-distance-euclidean/euclidean.js\";\n\n/**\n *\n * Embedding Distance Metric.\n *\n * COSINE: Cosine distance metric.\n * EUCLIDEAN: Euclidean distance metric.\n * MANHATTAN: Manhattan distance metric.\n * CHEBYSHEV: Chebyshev distance metric.\n * HAMMING: Hamming distance metric.\n */\nexport type EmbeddingDistanceType =\n  | \"cosine\"\n  | \"euclidean\"\n  | \"manhattan\"\n  | \"chebyshev\";\n\n/**\n * Embedding Distance Evaluation Chain Input.\n */\nexport interface EmbeddingDistanceEvalChainInput {\n  /**\n   * The embedding objects to vectorize the outputs.\n   */\n  embedding?: EmbeddingsInterface;\n\n  /**\n   * The distance metric to use\n   * for comparing the embeddings.\n   */\n  distanceMetric?: EmbeddingDistanceType;\n}\n\ntype VectorFunction = (xVector: number[], yVector: number[]) => number;\n\n/**\n * Get the distance function for the given distance type.\n * @param distance The distance type.\n * @return The distance function.\n */\nexport function getDistanceCalculationFunction(\n  distanceType: EmbeddingDistanceType\n): VectorFunction {\n  const distanceFunctions: { [key in EmbeddingDistanceType]: VectorFunction } =\n    {\n      cosine: (X: number[], Y: number[]) => 1.0 - cosine(X, Y),\n      euclidean,\n      manhattan,\n      chebyshev,\n    };\n\n  return distanceFunctions[distanceType];\n}\n\n/**\n * Compute the score based on the distance metric.\n * @param vectors The input vectors.\n * @param distanceMetric The distance metric.\n * @return The computed score.\n */\nexport function computeEvaluationScore(\n  vectors: number[][],\n  distanceMetric: EmbeddingDistanceType\n): number {\n  const metricFunction = getDistanceCalculationFunction(distanceMetric);\n  return metricFunction(vectors[0], vectors[1]);\n}\n\n/**\n * Use embedding distances to score semantic difference between\n * a prediction and reference.\n */\nexport class EmbeddingDistanceEvalChain\n  extends StringEvaluator\n  implements EmbeddingDistanceEvalChainInput\n{\n  requiresReference = true;\n\n  requiresInput = false;\n\n  outputKey = \"score\";\n\n  embedding?: EmbeddingsInterface;\n\n  distanceMetric: EmbeddingDistanceType = \"cosine\";\n\n  constructor(fields: EmbeddingDistanceEvalChainInput) {\n    super();\n    this.embedding = fields?.embedding || new OpenAIEmbeddings();\n    this.distanceMetric = fields?.distanceMetric || \"cosine\";\n  }\n\n  _chainType() {\n    return `embedding_${this.distanceMetric}_distance` as const;\n  }\n\n  async _evaluateStrings(\n    args: StringEvaluatorArgs,\n    config: Callbacks | BaseCallbackConfig | undefined\n  ): Promise<ChainValues> {\n    const result = await this.call(args, config);\n\n    return { [this.outputKey]: result[this.outputKey] };\n  }\n\n  get inputKeys(): string[] {\n    return [\"reference\", \"prediction\"];\n  }\n\n  get outputKeys(): string[] {\n    return [this.outputKey];\n  }\n\n  async _call(\n    values: ChainValues,\n    _runManager: CallbackManagerForChainRun | undefined\n  ): Promise<ChainValues> {\n    const { prediction, reference } = values;\n\n    if (!this.embedding) throw new Error(\"Embedding is undefined\");\n\n    const vectors = await this.embedding.embedDocuments([\n      prediction,\n      reference,\n    ]);\n\n    const score = computeEvaluationScore(vectors, this.distanceMetric);\n\n    return { [this.outputKey]: score };\n  }\n}\n\n/**\n * Use embedding distances to score semantic difference between two predictions.\n */\nexport class PairwiseEmbeddingDistanceEvalChain\n  extends PairwiseStringEvaluator\n  implements EmbeddingDistanceEvalChainInput\n{\n  requiresReference = false;\n\n  requiresInput = false;\n\n  outputKey = \"score\";\n\n  embedding?: EmbeddingsInterface;\n\n  distanceMetric: EmbeddingDistanceType = \"cosine\";\n\n  constructor(fields: EmbeddingDistanceEvalChainInput) {\n    super();\n    this.embedding = fields?.embedding || new OpenAIEmbeddings();\n    this.distanceMetric = fields?.distanceMetric || \"cosine\";\n  }\n\n  _chainType() {\n    return `pairwise_embedding_${this.distanceMetric}_distance` as const;\n  }\n\n  async _evaluateStringPairs(\n    args: PairwiseStringEvaluatorArgs,\n    config?: Callbacks | BaseCallbackConfig\n  ): Promise<ChainValues> {\n    const result = await this.call(args, config);\n\n    return { [this.outputKey]: result[this.outputKey] };\n  }\n\n  get inputKeys(): string[] {\n    return [\"prediction\", \"predictionB\"];\n  }\n\n  get outputKeys(): string[] {\n    return [this.outputKey];\n  }\n\n  async _call(\n    values: ChainValues,\n    _runManager: CallbackManagerForChainRun | undefined\n  ): Promise<ChainValues> {\n    const { prediction, predictionB } = values;\n\n    if (!this.embedding) throw new Error(\"Embedding is undefined\");\n\n    const vectors = await this.embedding.embedDocuments([\n      prediction,\n      predictionB,\n    ]);\n\n    const score = computeEvaluationScore(vectors, this.distanceMetric);\n\n    return { [this.outputKey]: score };\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAyDA,SAAgB,+BACdA,cACgB;CAChB,MAAMC,oBACJ;EACE,QAAQ,CAACC,GAAaC,MAAgB,IAAM,OAAO,GAAG,EAAE;EACxD;EACA;EACA;CACD;AAEH,QAAO,kBAAkB;AAC1B;;;;;;;AAQD,SAAgB,uBACdC,SACAC,gBACQ;CACR,MAAM,iBAAiB,+BAA+B,eAAe;AACrE,QAAO,eAAe,QAAQ,IAAI,QAAQ,GAAG;AAC9C;;;;;AAMD,IAAa,6BAAb,cACU,gBAEV;CACE,oBAAoB;CAEpB,gBAAgB;CAEhB,YAAY;CAEZ;CAEA,iBAAwC;CAExC,YAAYC,QAAyC;EACnD,OAAO;EACP,KAAK,YAAY,QAAQ,aAAa,IAAI;EAC1C,KAAK,iBAAiB,QAAQ,kBAAkB;CACjD;CAED,aAAa;AACX,SAAO,CAAC,UAAU,EAAE,KAAK,eAAe,SAAS,CAAC;CACnD;CAED,MAAM,iBACJC,MACAC,QACsB;EACtB,MAAM,SAAS,MAAM,KAAK,KAAK,MAAM,OAAO;AAE5C,SAAO,GAAG,KAAK,YAAY,OAAO,KAAK,WAAY;CACpD;CAED,IAAI,YAAsB;AACxB,SAAO,CAAC,aAAa,YAAa;CACnC;CAED,IAAI,aAAuB;AACzB,SAAO,CAAC,KAAK,SAAU;CACxB;CAED,MAAM,MACJC,QACAC,aACsB;EACtB,MAAM,EAAE,YAAY,WAAW,GAAG;AAElC,MAAI,CAAC,KAAK,UAAW,OAAM,IAAI,MAAM;EAErC,MAAM,UAAU,MAAM,KAAK,UAAU,eAAe,CAClD,YACA,SACD,EAAC;EAEF,MAAM,QAAQ,uBAAuB,SAAS,KAAK,eAAe;AAElE,SAAO,GAAG,KAAK,YAAY,MAAO;CACnC;AACF;;;;AAKD,IAAa,qCAAb,cACU,wBAEV;CACE,oBAAoB;CAEpB,gBAAgB;CAEhB,YAAY;CAEZ;CAEA,iBAAwC;CAExC,YAAYJ,QAAyC;EACnD,OAAO;EACP,KAAK,YAAY,QAAQ,aAAa,IAAI;EAC1C,KAAK,iBAAiB,QAAQ,kBAAkB;CACjD;CAED,aAAa;AACX,SAAO,CAAC,mBAAmB,EAAE,KAAK,eAAe,SAAS,CAAC;CAC5D;CAED,MAAM,qBACJK,MACAC,QACsB;EACtB,MAAM,SAAS,MAAM,KAAK,KAAK,MAAM,OAAO;AAE5C,SAAO,GAAG,KAAK,YAAY,OAAO,KAAK,WAAY;CACpD;CAED,IAAI,YAAsB;AACxB,SAAO,CAAC,cAAc,aAAc;CACrC;CAED,IAAI,aAAuB;AACzB,SAAO,CAAC,KAAK,SAAU;CACxB;CAED,MAAM,MACJH,QACAC,aACsB;EACtB,MAAM,EAAE,YAAY,aAAa,GAAG;AAEpC,MAAI,CAAC,KAAK,UAAW,OAAM,IAAI,MAAM;EAErC,MAAM,UAAU,MAAM,KAAK,UAAU,eAAe,CAClD,YACA,WACD,EAAC;EAEF,MAAM,QAAQ,uBAAuB,SAAS,KAAK,eAAe;AAElE,SAAO,GAAG,KAAK,YAAY,MAAO;CACnC;AACF"}
+{"version":3,"file":"base.js","names":["distanceType: EmbeddingDistanceType","distanceFunctions: { [key in EmbeddingDistanceType]: VectorFunction }","X: number[]","Y: number[]","vectors: number[][]","distanceMetric: EmbeddingDistanceType","fields: EmbeddingDistanceEvalChainInput","args: StringEvaluatorArgs","config: Callbacks | BaseCallbackConfig | undefined","values: ChainValues","_runManager: CallbackManagerForChainRun | undefined","args: PairwiseStringEvaluatorArgs","config?: Callbacks | BaseCallbackConfig"],"sources":["../../../src/evaluation/embedding_distance/base.ts"],"sourcesContent":["import type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport {\n  CallbackManagerForChainRun,\n  Callbacks,\n  BaseCallbackConfig,\n} from \"@langchain/core/callbacks/manager\";\nimport {\n  PairwiseStringEvaluator,\n  PairwiseStringEvaluatorArgs,\n  StringEvaluator,\n  StringEvaluatorArgs,\n} from \"../base.js\";\nimport { cosine } from \"../../util/ml-distance/similarities.js\";\nimport { chebyshev, manhattan } from \"../../util/ml-distance/distances.js\";\nimport { euclidean } from \"../../util/ml-distance-euclidean/euclidean.js\";\n\n/**\n *\n * Embedding Distance Metric.\n *\n * COSINE: Cosine distance metric.\n * EUCLIDEAN: Euclidean distance metric.\n * MANHATTAN: Manhattan distance metric.\n * CHEBYSHEV: Chebyshev distance metric.\n * HAMMING: Hamming distance metric.\n */\nexport type EmbeddingDistanceType =\n  | \"cosine\"\n  | \"euclidean\"\n  | \"manhattan\"\n  | \"chebyshev\";\n\n/**\n * Embedding Distance Evaluation Chain Input.\n */\nexport interface EmbeddingDistanceEvalChainInput {\n  /**\n   * The embedding objects to vectorize the outputs.\n   */\n  embedding?: EmbeddingsInterface;\n\n  /**\n   * The distance metric to use\n   * for comparing the embeddings.\n   */\n  distanceMetric?: EmbeddingDistanceType;\n}\n\ntype VectorFunction = (xVector: number[], yVector: number[]) => number;\n\n/**\n * Get the distance function for the given distance type.\n * @param distance The distance type.\n * @return The distance function.\n */\nexport function getDistanceCalculationFunction(\n  distanceType: EmbeddingDistanceType\n): VectorFunction {\n  const distanceFunctions: { [key in EmbeddingDistanceType]: VectorFunction } =\n    {\n      cosine: (X: number[], Y: number[]) => 1.0 - cosine(X, Y),\n      euclidean,\n      manhattan,\n      chebyshev,\n    };\n\n  return distanceFunctions[distanceType];\n}\n\n/**\n * Compute the score based on the distance metric.\n * @param vectors The input vectors.\n * @param distanceMetric The distance metric.\n * @return The computed score.\n */\nexport function computeEvaluationScore(\n  vectors: number[][],\n  distanceMetric: EmbeddingDistanceType\n): number {\n  const metricFunction = getDistanceCalculationFunction(distanceMetric);\n  return metricFunction(vectors[0], vectors[1]);\n}\n\n/**\n * Use embedding distances to score semantic difference between\n * a prediction and reference.\n */\nexport class EmbeddingDistanceEvalChain\n  extends StringEvaluator\n  implements EmbeddingDistanceEvalChainInput\n{\n  requiresReference = true;\n\n  requiresInput = false;\n\n  outputKey = \"score\";\n\n  embedding?: EmbeddingsInterface;\n\n  distanceMetric: EmbeddingDistanceType = \"cosine\";\n\n  constructor(fields: EmbeddingDistanceEvalChainInput) {\n    super();\n    this.embedding = fields?.embedding;\n    this.distanceMetric = fields?.distanceMetric || \"cosine\";\n  }\n\n  _chainType() {\n    return `embedding_${this.distanceMetric}_distance` as const;\n  }\n\n  async _evaluateStrings(\n    args: StringEvaluatorArgs,\n    config: Callbacks | BaseCallbackConfig | undefined\n  ): Promise<ChainValues> {\n    const result = await this.call(args, config);\n\n    return { [this.outputKey]: result[this.outputKey] };\n  }\n\n  get inputKeys(): string[] {\n    return [\"reference\", \"prediction\"];\n  }\n\n  get outputKeys(): string[] {\n    return [this.outputKey];\n  }\n\n  async _call(\n    values: ChainValues,\n    _runManager: CallbackManagerForChainRun | undefined\n  ): Promise<ChainValues> {\n    const { prediction, reference } = values;\n\n    if (!this.embedding) throw new Error(\"Embedding is undefined\");\n\n    const vectors = await this.embedding.embedDocuments([\n      prediction,\n      reference,\n    ]);\n\n    const score = computeEvaluationScore(vectors, this.distanceMetric);\n\n    return { [this.outputKey]: score };\n  }\n}\n\n/**\n * Use embedding distances to score semantic difference between two predictions.\n */\nexport class PairwiseEmbeddingDistanceEvalChain\n  extends PairwiseStringEvaluator\n  implements EmbeddingDistanceEvalChainInput\n{\n  requiresReference = false;\n\n  requiresInput = false;\n\n  outputKey = \"score\";\n\n  embedding?: EmbeddingsInterface;\n\n  distanceMetric: EmbeddingDistanceType = \"cosine\";\n\n  constructor(fields: EmbeddingDistanceEvalChainInput) {\n    super();\n    this.embedding = fields?.embedding;\n    this.distanceMetric = fields?.distanceMetric || \"cosine\";\n  }\n\n  _chainType() {\n    return `pairwise_embedding_${this.distanceMetric}_distance` as const;\n  }\n\n  async _evaluateStringPairs(\n    args: PairwiseStringEvaluatorArgs,\n    config?: Callbacks | BaseCallbackConfig\n  ): Promise<ChainValues> {\n    const result = await this.call(args, config);\n\n    return { [this.outputKey]: result[this.outputKey] };\n  }\n\n  get inputKeys(): string[] {\n    return [\"prediction\", \"predictionB\"];\n  }\n\n  get outputKeys(): string[] {\n    return [this.outputKey];\n  }\n\n  async _call(\n    values: ChainValues,\n    _runManager: CallbackManagerForChainRun | undefined\n  ): Promise<ChainValues> {\n    const { prediction, predictionB } = values;\n\n    if (!this.embedding) throw new Error(\"Embedding is undefined\");\n\n    const vectors = await this.embedding.embedDocuments([\n      prediction,\n      predictionB,\n    ]);\n\n    const score = computeEvaluationScore(vectors, this.distanceMetric);\n\n    return { [this.outputKey]: score };\n  }\n}\n"],"mappings":";;;;;;;;;;;AAwDA,SAAgB,+BACdA,cACgB;CAChB,MAAMC,oBACJ;EACE,QAAQ,CAACC,GAAaC,MAAgB,IAAM,OAAO,GAAG,EAAE;EACxD;EACA;EACA;CACD;AAEH,QAAO,kBAAkB;AAC1B;;;;;;;AAQD,SAAgB,uBACdC,SACAC,gBACQ;CACR,MAAM,iBAAiB,+BAA+B,eAAe;AACrE,QAAO,eAAe,QAAQ,IAAI,QAAQ,GAAG;AAC9C;;;;;AAMD,IAAa,6BAAb,cACU,gBAEV;CACE,oBAAoB;CAEpB,gBAAgB;CAEhB,YAAY;CAEZ;CAEA,iBAAwC;CAExC,YAAYC,QAAyC;EACnD,OAAO;EACP,KAAK,YAAY,QAAQ;EACzB,KAAK,iBAAiB,QAAQ,kBAAkB;CACjD;CAED,aAAa;AACX,SAAO,CAAC,UAAU,EAAE,KAAK,eAAe,SAAS,CAAC;CACnD;CAED,MAAM,iBACJC,MACAC,QACsB;EACtB,MAAM,SAAS,MAAM,KAAK,KAAK,MAAM,OAAO;AAE5C,SAAO,GAAG,KAAK,YAAY,OAAO,KAAK,WAAY;CACpD;CAED,IAAI,YAAsB;AACxB,SAAO,CAAC,aAAa,YAAa;CACnC;CAED,IAAI,aAAuB;AACzB,SAAO,CAAC,KAAK,SAAU;CACxB;CAED,MAAM,MACJC,QACAC,aACsB;EACtB,MAAM,EAAE,YAAY,WAAW,GAAG;AAElC,MAAI,CAAC,KAAK,UAAW,OAAM,IAAI,MAAM;EAErC,MAAM,UAAU,MAAM,KAAK,UAAU,eAAe,CAClD,YACA,SACD,EAAC;EAEF,MAAM,QAAQ,uBAAuB,SAAS,KAAK,eAAe;AAElE,SAAO,GAAG,KAAK,YAAY,MAAO;CACnC;AACF;;;;AAKD,IAAa,qCAAb,cACU,wBAEV;CACE,oBAAoB;CAEpB,gBAAgB;CAEhB,YAAY;CAEZ;CAEA,iBAAwC;CAExC,YAAYJ,QAAyC;EACnD,OAAO;EACP,KAAK,YAAY,QAAQ;EACzB,KAAK,iBAAiB,QAAQ,kBAAkB;CACjD;CAED,aAAa;AACX,SAAO,CAAC,mBAAmB,EAAE,KAAK,eAAe,SAAS,CAAC;CAC5D;CAED,MAAM,qBACJK,MACAC,QACsB;EACtB,MAAM,SAAS,MAAM,KAAK,KAAK,MAAM,OAAO;AAE5C,SAAO,GAAG,KAAK,YAAY,OAAO,KAAK,WAAY;CACpD;CAED,IAAI,YAAsB;AACxB,SAAO,CAAC,cAAc,aAAc;CACrC;CAED,IAAI,aAAuB;AACzB,SAAO,CAAC,KAAK,SAAU;CACxB;CAED,MAAM,MACJH,QACAC,aACsB;EACtB,MAAM,EAAE,YAAY,aAAa,GAAG;AAEpC,MAAI,CAAC,KAAK,UAAW,OAAM,IAAI,MAAM;EAErC,MAAM,UAAU,MAAM,KAAK,UAAU,eAAe,CAClD,YACA,WACD,EAAC;EAEF,MAAM,QAAQ,uBAAuB,SAAS,KAAK,eAAe;AAElE,SAAO,GAAG,KAAK,YAAY,MAAO;CACnC;AACF"}

package/dist/evaluation/loader.cjs

@@ -8,7 +8,6 @@ require('./embedding_distance/index.cjs');
 const require_pairwise = require('./comparison/pairwise.cjs');
 require('./comparison/index.cjs');
 const __langchain_core_language_models_chat_models = require_rolldown_runtime.__toESM(require("@langchain/core/language_models/chat_models"));
-const __langchain_openai = require_rolldown_runtime.__toESM(require("@langchain/openai"));
 
 //#region src/evaluation/loader.ts
 /**
@@ -20,28 +19,24 @@ const __langchain_openai = require_rolldown_runtime.__toESM(require("@langchain/
 *        - 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 __langchain_openai.ChatOpenAI({
-		model: "gpt-4",
-		temperature: 0
-	});
+	const { llm, chainOptions, criteria, agentTools } = options;
 	let evaluator;
 	switch (type) {
 		case "criteria":
-			evaluator = await require_criteria.CriteriaEvalChain.fromLLM(llm_, criteria, chainOptions);
+			evaluator = await require_criteria.CriteriaEvalChain.fromLLM(llm, criteria, chainOptions);
 			break;
 		case "labeled_criteria":
-			evaluator = await require_criteria.LabeledCriteriaEvalChain.fromLLM(llm_, criteria, chainOptions);
+			evaluator = await require_criteria.LabeledCriteriaEvalChain.fromLLM(llm, criteria, chainOptions);
 			break;
 		case "pairwise_string":
-			evaluator = await require_pairwise.PairwiseStringEvalChain.fromLLM(llm_, criteria, chainOptions);
+			evaluator = await require_pairwise.PairwiseStringEvalChain.fromLLM(llm, criteria, chainOptions);
 			break;
 		case "labeled_pairwise_string":
-			evaluator = await require_pairwise.LabeledPairwiseStringEvalChain.fromLLM(llm_, criteria, chainOptions);
+			evaluator = await require_pairwise.LabeledPairwiseStringEvalChain.fromLLM(llm, criteria, chainOptions);
 			break;
 		case "trajectory":
-			if (!(llm_ instanceof __langchain_core_language_models_chat_models.BaseChatModel)) throw new Error("LLM must be an instance of a base chat model.");
-			evaluator = await require_trajectory.TrajectoryEvalChain.fromLLM(llm_, agentTools, chainOptions);
+			if (!(llm instanceof __langchain_core_language_models_chat_models.BaseChatModel)) throw new Error("LLM must be an instance of a base chat model.");
+			evaluator = await require_trajectory.TrajectoryEvalChain.fromLLM(llm, agentTools, chainOptions);
 			break;
 		case "embedding_distance":
 			evaluator = new require_base.EmbeddingDistanceEvalChain({

package/dist/evaluation/loader.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"loader.cjs","names":["type: T","options?: LoadEvaluatorOptions","ChatOpenAI","evaluator: unknown","CriteriaEvalChain","LabeledCriteriaEvalChain","PairwiseStringEvalChain","LabeledPairwiseStringEvalChain","BaseChatModel","TrajectoryEvalChain","EmbeddingDistanceEvalChain","PairwiseEmbeddingDistanceEvalChain"],"sources":["../../src/evaluation/loader.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport {\n  CriteriaLike,\n  CriteriaEvalChain,\n  LabeledCriteriaEvalChain,\n} from \"./criteria/index.js\";\nimport type { EvaluatorType } from \"./types.js\";\nimport { LLMEvalChainInput } from \"./base.js\";\nimport {\n  LabeledPairwiseStringEvalChain,\n  PairwiseStringEvalChain,\n} from \"./comparison/index.js\";\nimport {\n  EmbeddingDistanceEvalChain,\n  EmbeddingDistanceEvalChainInput,\n  PairwiseEmbeddingDistanceEvalChain,\n} from \"./embedding_distance/index.js\";\nimport { TrajectoryEvalChain } from \"./agents/index.js\";\n\nexport type LoadEvaluatorOptions = EmbeddingDistanceEvalChainInput & {\n  llm?: BaseLanguageModelInterface;\n\n  chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>;\n  /**\n   * The criteria to use for the evaluator.\n   */\n  criteria?: CriteriaLike;\n\n  /**\n   * A list of tools available to the agent, for TrajectoryEvalChain.\n   */\n  agentTools?: StructuredToolInterface[];\n};\n\n/**\n * Load the requested evaluation chain specified by a string\n * @param type The type of evaluator to load.\n * @param options\n *        - llm The language model to use for the evaluator.\n *        - criteria The criteria to use for the evaluator.\n *        - agentTools A list of tools available to the agent,for TrajectoryEvalChain.\n */\nexport async function loadEvaluator<T extends keyof EvaluatorType>(\n  type: T,\n  options?: LoadEvaluatorOptions\n): Promise<EvaluatorType[T]> {\n  const { llm, chainOptions, criteria, agentTools } = options || {};\n\n  const llm_ =\n    llm ??\n    new ChatOpenAI({\n      model: \"gpt-4\",\n      temperature: 0.0,\n    });\n\n  let evaluator: unknown;\n  switch (type) {\n    case \"criteria\":\n      evaluator = await CriteriaEvalChain.fromLLM(llm_, criteria, chainOptions);\n      break;\n    case \"labeled_criteria\":\n      evaluator = await LabeledCriteriaEvalChain.fromLLM(\n        llm_,\n        criteria,\n        chainOptions\n      );\n      break;\n    case \"pairwise_string\":\n      evaluator = await PairwiseStringEvalChain.fromLLM(\n        llm_,\n        criteria,\n        chainOptions\n      );\n      break;\n    case \"labeled_pairwise_string\":\n      evaluator = await LabeledPairwiseStringEvalChain.fromLLM(\n        llm_,\n        criteria,\n        chainOptions\n      );\n      break;\n    case \"trajectory\":\n      // eslint-disable-next-line no-instanceof/no-instanceof\n      if (!(llm_ instanceof BaseChatModel)) {\n        throw new Error(\"LLM must be an instance of a base chat model.\");\n      }\n      evaluator = await TrajectoryEvalChain.fromLLM(\n        llm_,\n        agentTools,\n        chainOptions\n      );\n      break;\n    case \"embedding_distance\":\n      evaluator = new EmbeddingDistanceEvalChain({\n        embedding: options?.embedding,\n        distanceMetric: options?.distanceMetric,\n      });\n      break;\n    case \"pairwise_embedding_distance\":\n      evaluator = new PairwiseEmbeddingDistanceEvalChain({});\n      break;\n    default:\n      throw new Error(`Unknown type: ${type}`);\n  }\n\n  return evaluator as EvaluatorType[T];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA6CA,eAAsB,cACpBA,MACAC,SAC2B;CAC3B,MAAM,EAAE,KAAK,cAAc,UAAU,YAAY,GAAG,WAAW,CAAE;CAEjE,MAAM,OACJ,OACA,IAAIC,8BAAW;EACb,OAAO;EACP,aAAa;CACd;CAEH,IAAIC;AACJ,SAAQ,MAAR;EACE,KAAK;GACH,YAAY,MAAMC,mCAAkB,QAAQ,MAAM,UAAU,aAAa;AACzE;EACF,KAAK;GACH,YAAY,MAAMC,0CAAyB,QACzC,MACA,UACA,aACD;AACD;EACF,KAAK;GACH,YAAY,MAAMC,yCAAwB,QACxC,MACA,UACA,aACD;AACD;EACF,KAAK;GACH,YAAY,MAAMC,gDAA+B,QAC/C,MACA,UACA,aACD;AACD;EACF,KAAK;AAEH,OAAI,EAAE,gBAAgBC,4DACpB,OAAM,IAAI,MAAM;GAElB,YAAY,MAAMC,uCAAoB,QACpC,MACA,YACA,aACD;AACD;EACF,KAAK;GACH,YAAY,IAAIC,wCAA2B;IACzC,WAAW,SAAS;IACpB,gBAAgB,SAAS;GAC1B;AACD;EACF,KAAK;GACH,YAAY,IAAIC,gDAAmC,CAAE;AACrD;EACF,QACE,OAAM,IAAI,MAAM,CAAC,cAAc,EAAE,MAAM;CAC1C;AAED,QAAO;AACR"}
+{"version":3,"file":"loader.cjs","names":["type: T","options: LoadEvaluatorOptions","evaluator: unknown","CriteriaEvalChain","LabeledCriteriaEvalChain","PairwiseStringEvalChain","LabeledPairwiseStringEvalChain","BaseChatModel","TrajectoryEvalChain","EmbeddingDistanceEvalChain","PairwiseEmbeddingDistanceEvalChain"],"sources":["../../src/evaluation/loader.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport {\n  CriteriaLike,\n  CriteriaEvalChain,\n  LabeledCriteriaEvalChain,\n} from \"./criteria/index.js\";\nimport type { EvaluatorType } from \"./types.js\";\nimport { LLMEvalChainInput } from \"./base.js\";\nimport {\n  LabeledPairwiseStringEvalChain,\n  PairwiseStringEvalChain,\n} from \"./comparison/index.js\";\nimport {\n  EmbeddingDistanceEvalChain,\n  EmbeddingDistanceEvalChainInput,\n  PairwiseEmbeddingDistanceEvalChain,\n} from \"./embedding_distance/index.js\";\nimport { TrajectoryEvalChain } from \"./agents/index.js\";\n\nexport type LoadEvaluatorOptions = EmbeddingDistanceEvalChainInput & {\n  /**\n   * The language model to use for the evaluator.\n   */\n  llm: BaseLanguageModelInterface;\n  /**\n   * The options to pass to the evaluator chain.\n   */\n  chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>;\n  /**\n   * The criteria to use for the evaluator.\n   */\n  criteria?: CriteriaLike;\n\n  /**\n   * A list of tools available to the agent, for TrajectoryEvalChain.\n   */\n  agentTools?: StructuredToolInterface[];\n};\n\n/**\n * Load the requested evaluation chain specified by a string\n * @param type The type of evaluator to load.\n * @param options\n *        - llm The language model to use for the evaluator.\n *        - criteria The criteria to use for the evaluator.\n *        - agentTools A list of tools available to the agent,for TrajectoryEvalChain.\n */\nexport async function loadEvaluator<T extends keyof EvaluatorType>(\n  type: T,\n  options: LoadEvaluatorOptions\n): Promise<EvaluatorType[T]> {\n  const { llm, chainOptions, criteria, agentTools } = options;\n\n  let evaluator: unknown;\n  switch (type) {\n    case \"criteria\":\n      evaluator = await CriteriaEvalChain.fromLLM(llm, criteria, chainOptions);\n      break;\n    case \"labeled_criteria\":\n      evaluator = await LabeledCriteriaEvalChain.fromLLM(\n        llm,\n        criteria,\n        chainOptions\n      );\n      break;\n    case \"pairwise_string\":\n      evaluator = await PairwiseStringEvalChain.fromLLM(\n        llm,\n        criteria,\n        chainOptions\n      );\n      break;\n    case \"labeled_pairwise_string\":\n      evaluator = await LabeledPairwiseStringEvalChain.fromLLM(\n        llm,\n        criteria,\n        chainOptions\n      );\n      break;\n    case \"trajectory\":\n      // eslint-disable-next-line no-instanceof/no-instanceof\n      if (!(llm instanceof BaseChatModel)) {\n        throw new Error(\"LLM must be an instance of a base chat model.\");\n      }\n      evaluator = await TrajectoryEvalChain.fromLLM(\n        llm,\n        agentTools,\n        chainOptions\n      );\n      break;\n    case \"embedding_distance\":\n      evaluator = new EmbeddingDistanceEvalChain({\n        embedding: options?.embedding,\n        distanceMetric: options?.distanceMetric,\n      });\n      break;\n    case \"pairwise_embedding_distance\":\n      evaluator = new PairwiseEmbeddingDistanceEvalChain({});\n      break;\n    default:\n      throw new Error(`Unknown type: ${type}`);\n  }\n\n  return evaluator as EvaluatorType[T];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAiDA,eAAsB,cACpBA,MACAC,SAC2B;CAC3B,MAAM,EAAE,KAAK,cAAc,UAAU,YAAY,GAAG;CAEpD,IAAIC;AACJ,SAAQ,MAAR;EACE,KAAK;GACH,YAAY,MAAMC,mCAAkB,QAAQ,KAAK,UAAU,aAAa;AACxE;EACF,KAAK;GACH,YAAY,MAAMC,0CAAyB,QACzC,KACA,UACA,aACD;AACD;EACF,KAAK;GACH,YAAY,MAAMC,yCAAwB,QACxC,KACA,UACA,aACD;AACD;EACF,KAAK;GACH,YAAY,MAAMC,gDAA+B,QAC/C,KACA,UACA,aACD;AACD;EACF,KAAK;AAEH,OAAI,EAAE,eAAeC,4DACnB,OAAM,IAAI,MAAM;GAElB,YAAY,MAAMC,uCAAoB,QACpC,KACA,YACA,aACD;AACD;EACF,KAAK;GACH,YAAY,IAAIC,wCAA2B;IACzC,WAAW,SAAS;IACpB,gBAAgB,SAAS;GAC1B;AACD;EACF,KAAK;GACH,YAAY,IAAIC,gDAAmC,CAAE;AACrD;EACF,QACE,OAAM,IAAI,MAAM,CAAC,cAAc,EAAE,MAAM;CAC1C;AAED,QAAO;AACR"}

package/dist/evaluation/loader.d.cts

@@ -7,7 +7,13 @@ import { StructuredToolInterface } from "@langchain/core/tools";
 
 //#region src/evaluation/loader.d.ts
 type LoadEvaluatorOptions = EmbeddingDistanceEvalChainInput & {
-  llm?: BaseLanguageModelInterface;
+  /**
+   * The language model to use for the evaluator.
+   */
+  llm: BaseLanguageModelInterface;
+  /**
+   * The options to pass to the evaluator chain.
+   */
   chainOptions?: Partial<Omit<LLMEvalChainInput, "llm">>;
   /**
    * The criteria to use for the evaluator.
@@ -26,7 +32,7 @@ type LoadEvaluatorOptions = EmbeddingDistanceEvalChainInput & {
  *        - criteria The criteria to use for the evaluator.
  *        - agentTools A list of tools available to the agent,for TrajectoryEvalChain.
  */
-declare function loadEvaluator<T extends keyof EvaluatorType>(type: T, options?: LoadEvaluatorOptions): Promise<EvaluatorType[T]>;
+declare function loadEvaluator<T extends keyof EvaluatorType>(type: T, options: LoadEvaluatorOptions): Promise<EvaluatorType[T]>;
 //#endregion
 export { LoadEvaluatorOptions, loadEvaluator };
 //# sourceMappingURL=loader.d.cts.map

package/dist/evaluation/loader.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.cts","names":["BaseLanguageModelInterface","StructuredToolInterface","CriteriaLike","EvaluatorType","LLMEvalChainInput","EmbeddingDistanceEvalChainInput","LoadEvaluatorOptions","Omit","Partial","loadEvaluator","T","Promise"],"sources":["../../src/evaluation/loader.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { CriteriaLike } from \"./criteria/index.js\";\nimport type { EvaluatorType } from \"./types.js\";\nimport { LLMEvalChainInput } from \"./base.js\";\nimport { EmbeddingDistanceEvalChainInput } from \"./embedding_distance/index.js\";\nexport type LoadEvaluatorOptions = EmbeddingDistanceEvalChainInput & {\n    llm?: BaseLanguageModelInterface;\n    chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>;\n    /**\n     * The criteria to use for the evaluator.\n     */\n    criteria?: CriteriaLike;\n    /**\n     * A list of tools available to the agent, for TrajectoryEvalChain.\n     */\n    agentTools?: StructuredToolInterface[];\n};\n/**\n * Load the requested evaluation chain specified by a string\n * @param type The type of evaluator to load.\n * @param options\n *        - llm The language model to use for the evaluator.\n *        - criteria The criteria to use for the evaluator.\n *        - agentTools A list of tools available to the agent,for TrajectoryEvalChain.\n */\nexport declare function loadEvaluator<T extends keyof EvaluatorType>(type: T, options?: LoadEvaluatorOptions): Promise<EvaluatorType[T]>;\n"],"mappings":";;;;;;;;KAMYM,oBAAAA,GAAuBD;QACzBL;EADEM,YAAAA,CAAAA,EAEOE,OAFPF,CAEeC,IAFK,CAEAH,iBAFA,EAAA,KAAA,CAAA,CAAA;EAAA;;;EACI,QACJA,CAAAA,EAIjBF,YAJiBE;EAAiB;;;EAItB,UAIVH,CAAAA,EAAAA,uBAAAA,EAAAA;AAAuB,CAAA;AAUxC;;;;;;;;AAAsH,iBAA9FQ,aAA8F,CAAA,UAAA,MAAhEN,aAAgE,CAAA,CAAA,IAAA,EAA3CO,CAA2C,EAAA,OAAA,CAAA,EAA9BJ,oBAA8B,CAAA,EAAPK,OAAO,CAACR,aAAD,CAAeO,CAAf,CAAA,CAAA"}
+{"version":3,"file":"loader.d.cts","names":["BaseLanguageModelInterface","StructuredToolInterface","CriteriaLike","EvaluatorType","LLMEvalChainInput","EmbeddingDistanceEvalChainInput","LoadEvaluatorOptions","Omit","Partial","loadEvaluator","T","Promise"],"sources":["../../src/evaluation/loader.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { CriteriaLike } from \"./criteria/index.js\";\nimport type { EvaluatorType } from \"./types.js\";\nimport { LLMEvalChainInput } from \"./base.js\";\nimport { EmbeddingDistanceEvalChainInput } from \"./embedding_distance/index.js\";\nexport type LoadEvaluatorOptions = EmbeddingDistanceEvalChainInput & {\n    /**\n     * The language model to use for the evaluator.\n     */\n    llm: BaseLanguageModelInterface;\n    /**\n     * The options to pass to the evaluator chain.\n     */\n    chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>;\n    /**\n     * The criteria to use for the evaluator.\n     */\n    criteria?: CriteriaLike;\n    /**\n     * A list of tools available to the agent, for TrajectoryEvalChain.\n     */\n    agentTools?: StructuredToolInterface[];\n};\n/**\n * Load the requested evaluation chain specified by a string\n * @param type The type of evaluator to load.\n * @param options\n *        - llm The language model to use for the evaluator.\n *        - criteria The criteria to use for the evaluator.\n *        - agentTools A list of tools available to the agent,for TrajectoryEvalChain.\n */\nexport declare function loadEvaluator<T extends keyof EvaluatorType>(type: T, options: LoadEvaluatorOptions): Promise<EvaluatorType[T]>;\n"],"mappings":";;;;;;;;KAMYM,oBAAAA,GAAuBD;;AAAnC;;EAAgC,GAAGA,EAI1BL,0BAJ0BK;EAA+B;;;EAQnC,YAAZG,CAAAA,EAAAA,OAAAA,CAAQD,IAARC,CAAaJ,iBAAbI,EAAAA,KAAAA,CAAAA,CAAAA;EAAO;;AAQc;EAUhBC,QAAAA,CAAAA,EAdTP,YAcsB;EAAA;;;EAAuC,UAAWI,CAAAA,EAVtEL,uBAUsEK,EAAAA;CAAoB;;;AAAU;;;;;;iBAA7FG,8BAA8BN,qBAAqBO,YAAYJ,uBAAuBK,QAAQR,cAAcO"}

package/dist/evaluation/loader.d.ts

@@ -7,7 +7,13 @@ import { BaseLanguageModelInterface } from "@langchain/core/language_models/base
 
 //#region src/evaluation/loader.d.ts
 type LoadEvaluatorOptions = EmbeddingDistanceEvalChainInput & {
-  llm?: BaseLanguageModelInterface;
+  /**
+   * The language model to use for the evaluator.
+   */
+  llm: BaseLanguageModelInterface;
+  /**
+   * The options to pass to the evaluator chain.
+   */
   chainOptions?: Partial<Omit<LLMEvalChainInput, "llm">>;
   /**
    * The criteria to use for the evaluator.
@@ -26,7 +32,7 @@ type LoadEvaluatorOptions = EmbeddingDistanceEvalChainInput & {
  *        - criteria The criteria to use for the evaluator.
  *        - agentTools A list of tools available to the agent,for TrajectoryEvalChain.
  */
-declare function loadEvaluator<T extends keyof EvaluatorType>(type: T, options?: LoadEvaluatorOptions): Promise<EvaluatorType[T]>;
+declare function loadEvaluator<T extends keyof EvaluatorType>(type: T, options: LoadEvaluatorOptions): Promise<EvaluatorType[T]>;
 //#endregion
 export { LoadEvaluatorOptions, loadEvaluator };
 //# sourceMappingURL=loader.d.ts.map

package/dist/evaluation/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","names":["BaseLanguageModelInterface","StructuredToolInterface","CriteriaLike","EvaluatorType","LLMEvalChainInput","EmbeddingDistanceEvalChainInput","LoadEvaluatorOptions","Omit","Partial","loadEvaluator","T","Promise"],"sources":["../../src/evaluation/loader.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { CriteriaLike } from \"./criteria/index.js\";\nimport type { EvaluatorType } from \"./types.js\";\nimport { LLMEvalChainInput } from \"./base.js\";\nimport { EmbeddingDistanceEvalChainInput } from \"./embedding_distance/index.js\";\nexport type LoadEvaluatorOptions = EmbeddingDistanceEvalChainInput & {\n    llm?: BaseLanguageModelInterface;\n    chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>;\n    /**\n     * The criteria to use for the evaluator.\n     */\n    criteria?: CriteriaLike;\n    /**\n     * A list of tools available to the agent, for TrajectoryEvalChain.\n     */\n    agentTools?: StructuredToolInterface[];\n};\n/**\n * Load the requested evaluation chain specified by a string\n * @param type The type of evaluator to load.\n * @param options\n *        - llm The language model to use for the evaluator.\n *        - criteria The criteria to use for the evaluator.\n *        - agentTools A list of tools available to the agent,for TrajectoryEvalChain.\n */\nexport declare function loadEvaluator<T extends keyof EvaluatorType>(type: T, options?: LoadEvaluatorOptions): Promise<EvaluatorType[T]>;\n"],"mappings":";;;;;;;;KAMYM,oBAAAA,GAAuBD;QACzBL;EADEM,YAAAA,CAAAA,EAEOE,OAFPF,CAEeC,IAFK,CAEAH,iBAFA,EAAA,KAAA,CAAA,CAAA;EAAA;;;EACI,QACJA,CAAAA,EAIjBF,YAJiBE;EAAiB;;;EAItB,UAIVH,CAAAA,EAAAA,uBAAAA,EAAAA;AAAuB,CAAA;AAUxC;;;;;;;;AAAsH,iBAA9FQ,aAA8F,CAAA,UAAA,MAAhEN,aAAgE,CAAA,CAAA,IAAA,EAA3CO,CAA2C,EAAA,OAAA,CAAA,EAA9BJ,oBAA8B,CAAA,EAAPK,OAAO,CAACR,aAAD,CAAeO,CAAf,CAAA,CAAA"}
+{"version":3,"file":"loader.d.ts","names":["BaseLanguageModelInterface","StructuredToolInterface","CriteriaLike","EvaluatorType","LLMEvalChainInput","EmbeddingDistanceEvalChainInput","LoadEvaluatorOptions","Omit","Partial","loadEvaluator","T","Promise"],"sources":["../../src/evaluation/loader.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { CriteriaLike } from \"./criteria/index.js\";\nimport type { EvaluatorType } from \"./types.js\";\nimport { LLMEvalChainInput } from \"./base.js\";\nimport { EmbeddingDistanceEvalChainInput } from \"./embedding_distance/index.js\";\nexport type LoadEvaluatorOptions = EmbeddingDistanceEvalChainInput & {\n    /**\n     * The language model to use for the evaluator.\n     */\n    llm: BaseLanguageModelInterface;\n    /**\n     * The options to pass to the evaluator chain.\n     */\n    chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>;\n    /**\n     * The criteria to use for the evaluator.\n     */\n    criteria?: CriteriaLike;\n    /**\n     * A list of tools available to the agent, for TrajectoryEvalChain.\n     */\n    agentTools?: StructuredToolInterface[];\n};\n/**\n * Load the requested evaluation chain specified by a string\n * @param type The type of evaluator to load.\n * @param options\n *        - llm The language model to use for the evaluator.\n *        - criteria The criteria to use for the evaluator.\n *        - agentTools A list of tools available to the agent,for TrajectoryEvalChain.\n */\nexport declare function loadEvaluator<T extends keyof EvaluatorType>(type: T, options: LoadEvaluatorOptions): Promise<EvaluatorType[T]>;\n"],"mappings":";;;;;;;;KAMYM,oBAAAA,GAAuBD;;AAAnC;;EAAgC,GAAGA,EAI1BL,0BAJ0BK;EAA+B;;;EAQnC,YAAZG,CAAAA,EAAAA,OAAAA,CAAQD,IAARC,CAAaJ,iBAAbI,EAAAA,KAAAA,CAAAA,CAAAA;EAAO;;AAQc;EAUhBC,QAAAA,CAAAA,EAdTP,YAcsB;EAAA;;;EAAuC,UAAWI,CAAAA,EAVtEL,uBAUsEK,EAAAA;CAAoB;;;AAAU;;;;;;iBAA7FG,8BAA8BN,qBAAqBO,YAAYJ,uBAAuBK,QAAQR,cAAcO"}

package/dist/evaluation/loader.js

@@ -7,7 +7,6 @@ import "./embedding_distance/index.js";
 import { LabeledPairwiseStringEvalChain, PairwiseStringEvalChain } from "./comparison/pairwise.js";
 import "./comparison/index.js";
 import { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import { ChatOpenAI } from "@langchain/openai";
 
 //#region src/evaluation/loader.ts
 /**
@@ -19,28 +18,24 @@ import { ChatOpenAI } from "@langchain/openai";
 *        - 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 ChatOpenAI({
-		model: "gpt-4",
-		temperature: 0
-	});
+	const { llm, chainOptions, criteria, agentTools } = options;
 	let evaluator;
 	switch (type) {
 		case "criteria":
-			evaluator = await CriteriaEvalChain.fromLLM(llm_, criteria, chainOptions);
+			evaluator = await CriteriaEvalChain.fromLLM(llm, criteria, chainOptions);
 			break;
 		case "labeled_criteria":
-			evaluator = await LabeledCriteriaEvalChain.fromLLM(llm_, criteria, chainOptions);
+			evaluator = await LabeledCriteriaEvalChain.fromLLM(llm, criteria, chainOptions);
 			break;
 		case "pairwise_string":
-			evaluator = await PairwiseStringEvalChain.fromLLM(llm_, criteria, chainOptions);
+			evaluator = await PairwiseStringEvalChain.fromLLM(llm, criteria, chainOptions);
 			break;
 		case "labeled_pairwise_string":
-			evaluator = await LabeledPairwiseStringEvalChain.fromLLM(llm_, criteria, chainOptions);
+			evaluator = await LabeledPairwiseStringEvalChain.fromLLM(llm, criteria, chainOptions);
 			break;
 		case "trajectory":
-			if (!(llm_ instanceof BaseChatModel)) throw new Error("LLM must be an instance of a base chat model.");
-			evaluator = await TrajectoryEvalChain.fromLLM(llm_, agentTools, chainOptions);
+			if (!(llm instanceof BaseChatModel)) throw new Error("LLM must be an instance of a base chat model.");
+			evaluator = await TrajectoryEvalChain.fromLLM(llm, agentTools, chainOptions);
 			break;
 		case "embedding_distance":
 			evaluator = new EmbeddingDistanceEvalChain({

package/dist/evaluation/loader.js.map

@@ -1 +1 @@
-{"version":3,"file":"loader.js","names":["type: T","options?: LoadEvaluatorOptions","evaluator: unknown"],"sources":["../../src/evaluation/loader.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport {\n  CriteriaLike,\n  CriteriaEvalChain,\n  LabeledCriteriaEvalChain,\n} from \"./criteria/index.js\";\nimport type { EvaluatorType } from \"./types.js\";\nimport { LLMEvalChainInput } from \"./base.js\";\nimport {\n  LabeledPairwiseStringEvalChain,\n  PairwiseStringEvalChain,\n} from \"./comparison/index.js\";\nimport {\n  EmbeddingDistanceEvalChain,\n  EmbeddingDistanceEvalChainInput,\n  PairwiseEmbeddingDistanceEvalChain,\n} from \"./embedding_distance/index.js\";\nimport { TrajectoryEvalChain } from \"./agents/index.js\";\n\nexport type LoadEvaluatorOptions = EmbeddingDistanceEvalChainInput & {\n  llm?: BaseLanguageModelInterface;\n\n  chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>;\n  /**\n   * The criteria to use for the evaluator.\n   */\n  criteria?: CriteriaLike;\n\n  /**\n   * A list of tools available to the agent, for TrajectoryEvalChain.\n   */\n  agentTools?: StructuredToolInterface[];\n};\n\n/**\n * Load the requested evaluation chain specified by a string\n * @param type The type of evaluator to load.\n * @param options\n *        - llm The language model to use for the evaluator.\n *        - criteria The criteria to use for the evaluator.\n *        - agentTools A list of tools available to the agent,for TrajectoryEvalChain.\n */\nexport async function loadEvaluator<T extends keyof EvaluatorType>(\n  type: T,\n  options?: LoadEvaluatorOptions\n): Promise<EvaluatorType[T]> {\n  const { llm, chainOptions, criteria, agentTools } = options || {};\n\n  const llm_ =\n    llm ??\n    new ChatOpenAI({\n      model: \"gpt-4\",\n      temperature: 0.0,\n    });\n\n  let evaluator: unknown;\n  switch (type) {\n    case \"criteria\":\n      evaluator = await CriteriaEvalChain.fromLLM(llm_, criteria, chainOptions);\n      break;\n    case \"labeled_criteria\":\n      evaluator = await LabeledCriteriaEvalChain.fromLLM(\n        llm_,\n        criteria,\n        chainOptions\n      );\n      break;\n    case \"pairwise_string\":\n      evaluator = await PairwiseStringEvalChain.fromLLM(\n        llm_,\n        criteria,\n        chainOptions\n      );\n      break;\n    case \"labeled_pairwise_string\":\n      evaluator = await LabeledPairwiseStringEvalChain.fromLLM(\n        llm_,\n        criteria,\n        chainOptions\n      );\n      break;\n    case \"trajectory\":\n      // eslint-disable-next-line no-instanceof/no-instanceof\n      if (!(llm_ instanceof BaseChatModel)) {\n        throw new Error(\"LLM must be an instance of a base chat model.\");\n      }\n      evaluator = await TrajectoryEvalChain.fromLLM(\n        llm_,\n        agentTools,\n        chainOptions\n      );\n      break;\n    case \"embedding_distance\":\n      evaluator = new EmbeddingDistanceEvalChain({\n        embedding: options?.embedding,\n        distanceMetric: options?.distanceMetric,\n      });\n      break;\n    case \"pairwise_embedding_distance\":\n      evaluator = new PairwiseEmbeddingDistanceEvalChain({});\n      break;\n    default:\n      throw new Error(`Unknown type: ${type}`);\n  }\n\n  return evaluator as EvaluatorType[T];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA6CA,eAAsB,cACpBA,MACAC,SAC2B;CAC3B,MAAM,EAAE,KAAK,cAAc,UAAU,YAAY,GAAG,WAAW,CAAE;CAEjE,MAAM,OACJ,OACA,IAAI,WAAW;EACb,OAAO;EACP,aAAa;CACd;CAEH,IAAIC;AACJ,SAAQ,MAAR;EACE,KAAK;GACH,YAAY,MAAM,kBAAkB,QAAQ,MAAM,UAAU,aAAa;AACzE;EACF,KAAK;GACH,YAAY,MAAM,yBAAyB,QACzC,MACA,UACA,aACD;AACD;EACF,KAAK;GACH,YAAY,MAAM,wBAAwB,QACxC,MACA,UACA,aACD;AACD;EACF,KAAK;GACH,YAAY,MAAM,+BAA+B,QAC/C,MACA,UACA,aACD;AACD;EACF,KAAK;AAEH,OAAI,EAAE,gBAAgB,eACpB,OAAM,IAAI,MAAM;GAElB,YAAY,MAAM,oBAAoB,QACpC,MACA,YACA,aACD;AACD;EACF,KAAK;GACH,YAAY,IAAI,2BAA2B;IACzC,WAAW,SAAS;IACpB,gBAAgB,SAAS;GAC1B;AACD;EACF,KAAK;GACH,YAAY,IAAI,mCAAmC,CAAE;AACrD;EACF,QACE,OAAM,IAAI,MAAM,CAAC,cAAc,EAAE,MAAM;CAC1C;AAED,QAAO;AACR"}
+{"version":3,"file":"loader.js","names":["type: T","options: LoadEvaluatorOptions","evaluator: unknown"],"sources":["../../src/evaluation/loader.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport {\n  CriteriaLike,\n  CriteriaEvalChain,\n  LabeledCriteriaEvalChain,\n} from \"./criteria/index.js\";\nimport type { EvaluatorType } from \"./types.js\";\nimport { LLMEvalChainInput } from \"./base.js\";\nimport {\n  LabeledPairwiseStringEvalChain,\n  PairwiseStringEvalChain,\n} from \"./comparison/index.js\";\nimport {\n  EmbeddingDistanceEvalChain,\n  EmbeddingDistanceEvalChainInput,\n  PairwiseEmbeddingDistanceEvalChain,\n} from \"./embedding_distance/index.js\";\nimport { TrajectoryEvalChain } from \"./agents/index.js\";\n\nexport type LoadEvaluatorOptions = EmbeddingDistanceEvalChainInput & {\n  /**\n   * The language model to use for the evaluator.\n   */\n  llm: BaseLanguageModelInterface;\n  /**\n   * The options to pass to the evaluator chain.\n   */\n  chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>;\n  /**\n   * The criteria to use for the evaluator.\n   */\n  criteria?: CriteriaLike;\n\n  /**\n   * A list of tools available to the agent, for TrajectoryEvalChain.\n   */\n  agentTools?: StructuredToolInterface[];\n};\n\n/**\n * Load the requested evaluation chain specified by a string\n * @param type The type of evaluator to load.\n * @param options\n *        - llm The language model to use for the evaluator.\n *        - criteria The criteria to use for the evaluator.\n *        - agentTools A list of tools available to the agent,for TrajectoryEvalChain.\n */\nexport async function loadEvaluator<T extends keyof EvaluatorType>(\n  type: T,\n  options: LoadEvaluatorOptions\n): Promise<EvaluatorType[T]> {\n  const { llm, chainOptions, criteria, agentTools } = options;\n\n  let evaluator: unknown;\n  switch (type) {\n    case \"criteria\":\n      evaluator = await CriteriaEvalChain.fromLLM(llm, criteria, chainOptions);\n      break;\n    case \"labeled_criteria\":\n      evaluator = await LabeledCriteriaEvalChain.fromLLM(\n        llm,\n        criteria,\n        chainOptions\n      );\n      break;\n    case \"pairwise_string\":\n      evaluator = await PairwiseStringEvalChain.fromLLM(\n        llm,\n        criteria,\n        chainOptions\n      );\n      break;\n    case \"labeled_pairwise_string\":\n      evaluator = await LabeledPairwiseStringEvalChain.fromLLM(\n        llm,\n        criteria,\n        chainOptions\n      );\n      break;\n    case \"trajectory\":\n      // eslint-disable-next-line no-instanceof/no-instanceof\n      if (!(llm instanceof BaseChatModel)) {\n        throw new Error(\"LLM must be an instance of a base chat model.\");\n      }\n      evaluator = await TrajectoryEvalChain.fromLLM(\n        llm,\n        agentTools,\n        chainOptions\n      );\n      break;\n    case \"embedding_distance\":\n      evaluator = new EmbeddingDistanceEvalChain({\n        embedding: options?.embedding,\n        distanceMetric: options?.distanceMetric,\n      });\n      break;\n    case \"pairwise_embedding_distance\":\n      evaluator = new PairwiseEmbeddingDistanceEvalChain({});\n      break;\n    default:\n      throw new Error(`Unknown type: ${type}`);\n  }\n\n  return evaluator as EvaluatorType[T];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAiDA,eAAsB,cACpBA,MACAC,SAC2B;CAC3B,MAAM,EAAE,KAAK,cAAc,UAAU,YAAY,GAAG;CAEpD,IAAIC;AACJ,SAAQ,MAAR;EACE,KAAK;GACH,YAAY,MAAM,kBAAkB,QAAQ,KAAK,UAAU,aAAa;AACxE;EACF,KAAK;GACH,YAAY,MAAM,yBAAyB,QACzC,KACA,UACA,aACD;AACD;EACF,KAAK;GACH,YAAY,MAAM,wBAAwB,QACxC,KACA,UACA,aACD;AACD;EACF,KAAK;GACH,YAAY,MAAM,+BAA+B,QAC/C,KACA,UACA,aACD;AACD;EACF,KAAK;AAEH,OAAI,EAAE,eAAe,eACnB,OAAM,IAAI,MAAM;GAElB,YAAY,MAAM,oBAAoB,QACpC,KACA,YACA,aACD;AACD;EACF,KAAK;GACH,YAAY,IAAI,2BAA2B;IACzC,WAAW,SAAS;IACpB,gBAAgB,SAAS;GAC1B;AACD;EACF,KAAK;GACH,YAAY,IAAI,mCAAmC,CAAE;AACrD;EACF,QACE,OAAM,IAAI,MAAM,CAAC,cAAc,EAAE,MAAM;CAC1C;AAED,QAAO;AACR"}