@langchain/classic 1.0.4 → 1.0.6-dev-1765431816670

package/dist/document_transformers/openai_functions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openai_functions.d.ts","names":["Document","MappingDocumentTransformer","ChatOpenAI","InteropZodObject","JsonSchema7ObjectType","BaseChain","TaggingChainOptions","MetadataTagger","Promise","createMetadataTagger","createMetadataTaggerFromZod"],"sources":["../../src/document_transformers/openai_functions.d.ts"],"sourcesContent":["import { Document, MappingDocumentTransformer } from \"@langchain/core/documents\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nimport { InteropZodObject } from \"@langchain/core/utils/types\";\nimport { type JsonSchema7ObjectType } from \"@langchain/core/utils/json_schema\";\nimport { BaseChain } from \"../chains/base.js\";\nimport { TaggingChainOptions } from \"../chains/openai_functions/index.js\";\n/**\n * A transformer that tags metadata to a document using a tagging chain.\n */\nexport declare class MetadataTagger extends MappingDocumentTransformer {\n    static lc_name(): string;\n    protected taggingChain: BaseChain;\n    constructor(fields: {\n        taggingChain: BaseChain;\n    });\n    _transformDocument(document: Document): Promise<Document>;\n}\nexport declare function createMetadataTagger(schema: JsonSchema7ObjectType, options: TaggingChainOptions & {\n    llm?: ChatOpenAI;\n}): MetadataTagger;\nexport declare function createMetadataTaggerFromZod(schema: InteropZodObject, options: TaggingChainOptions & {\n    llm?: ChatOpenAI;\n}): MetadataTagger;\n"],"mappings":";;;;;;;;;;;AASA;AAAmC,cAAdO,cAAAA,SAAuBN,0BAAAA,CAAT;EAAA,OAEPI,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAS,UAEfA,YAAAA,EAFMA,SAENA;EAAS,WAEEL,CAAAA,MAAAA,EAAAA;IAAmBA,YAAAA,EAF9BK,SAE8BL;EAAQ,CAAA;EAAT,kBANPC,CAAAA,QAAAA,EAMXD,QANWC,CAAAA,EAMAO,OANAP,CAMQD,QANRC,CAAAA;AAA0B;AAQ9CQ,iBAAAA,oBAAAA,CAAoB,MAAA,EAASL,qBAAT,EAAA,OAAA,EAAyCE,mBAAzC,GAAA;EAAA,GAAA,CAAA,EAClCJ,UADkC;CAAA,CAAA,EAExCK,cAFiDH;AAAgCE,iBAG7DI,2BAAAA,CAH6DJ,MAAAA,EAGzBH,gBAHyBG,EAAAA,OAAAA,EAGEA,mBAHFA,GAAAA;EAAmB,GAC9FJ,CAAAA,EAGAA,UAHAA;CAAU,CAAA,EAIhBK,cAHAA"}
+{"version":3,"file":"openai_functions.d.ts","names":["Document","MappingDocumentTransformer","ChatOpenAI","InteropZodObject","JsonSchema7ObjectType","BaseChain","TaggingChainOptions","MetadataTagger","Promise","createMetadataTagger","createMetadataTaggerFromZod"],"sources":["../../src/document_transformers/openai_functions.d.ts"],"sourcesContent":["import { Document, MappingDocumentTransformer } from \"@langchain/core/documents\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nimport { InteropZodObject } from \"@langchain/core/utils/types\";\nimport { type JsonSchema7ObjectType } from \"@langchain/core/utils/json_schema\";\nimport { BaseChain } from \"../chains/base.js\";\nimport { TaggingChainOptions } from \"../chains/openai_functions/index.js\";\n/**\n * A transformer that tags metadata to a document using a tagging chain.\n */\nexport declare class MetadataTagger extends MappingDocumentTransformer {\n    static lc_name(): string;\n    protected taggingChain: BaseChain;\n    constructor(fields: {\n        taggingChain: BaseChain;\n    });\n    _transformDocument(document: Document): Promise<Document>;\n}\nexport declare function createMetadataTagger(schema: JsonSchema7ObjectType, options: TaggingChainOptions & {\n    llm?: ChatOpenAI;\n}): MetadataTagger;\nexport declare function createMetadataTaggerFromZod(schema: InteropZodObject, options: TaggingChainOptions & {\n    llm?: ChatOpenAI;\n}): MetadataTagger;\n//# sourceMappingURL=openai_functions.d.ts.map"],"mappings":";;;;;;;;;;;;AASqBO,cAAAA,cAAAA,SAAuBN,0BAAAA,CAAT;EAEPI,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAENA,UAAAA,YAAAA,EAFMA,SAENA;EAEWL,WAAAA,CAAAA,MAAAA,EAAAA;IAAmBA,YAAAA,EAF9BK,SAE8BL;EAARQ,CAAAA;EANAP,kBAAAA,CAAAA,QAAAA,EAMXD,QANWC,CAAAA,EAMAO,OANAP,CAMQD,QANRC,CAAAA;AAA0B;AAQ9CQ,iBAAAA,oBAAAA,CAAoB,MAAA,EAASL,qBAAT,EAAA,OAAA,EAAyCE,mBAAzC,GAAA;EAASF,GAAAA,CAAAA,EAC3CF,UAD2CE;CAAgCE,CAAAA,EAEjFC,cAFiFD;AAC3EJ,iBAEcQ,2BAAAA,CAFdR,MAAAA,EAEkDC,gBAFlDD,EAAAA,OAAAA,EAE6EI,mBAF7EJ,GAAAA;EACNK,GAAAA,CAAAA,EAEML,UAFNK;AAAc,CAAA,CAAA,EAGdA,cAHc"}

package/dist/embeddings/cache_backed.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"cache_backed.d.cts","names":["EmbeddingsInterface","Embeddings","BaseStore","AsyncCallerParams","CacheBackedEmbeddingsFields","CacheBackedEmbeddings","Promise","Uint8Array"],"sources":["../../src/embeddings/cache_backed.d.ts"],"sourcesContent":["import { type EmbeddingsInterface, Embeddings } from \"@langchain/core/embeddings\";\nimport { BaseStore } from \"@langchain/core/stores\";\nimport { AsyncCallerParams } from \"@langchain/core/utils/async_caller\";\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 * 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 declare class CacheBackedEmbeddings extends Embeddings {\n    protected underlyingEmbeddings: EmbeddingsInterface;\n    protected documentEmbeddingStore: BaseStore<string, number[]>;\n    constructor(fields: CacheBackedEmbeddingsFields);\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    embedQuery(document: string): Promise<number[]>;\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    embedDocuments(documents: string[]): Promise<number[][]>;\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(underlyingEmbeddings: EmbeddingsInterface, documentEmbeddingStore: BaseStore<string, Uint8Array>, options?: {\n        namespace?: string;\n    }): CacheBackedEmbeddings;\n}\n"],"mappings":";;;;;;;;AAOA;;AAC0BA,UADTI,2BAAAA,SAAoCD,iBAC3BH,CAAAA;EAAmB,oBACjBE,EADFF,mBACEE;EAAS,sBAFgBC,EAEzBD,SAFyBC,CAAAA,MAAAA,EAAAA,MAAAA,EAAAA,CAAAA;AAAiB;AAmDtE;;;;;;;;;;;;AAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAxCE,qBAAAA,SAA8BJ,UAAAA;kCACfD;oCACEE;sBACdE;;;;;;;;;;;;;;;;gCAgBUE;;;;;;;;;;;uCAWOA;;;;;;;;;8CASON,6CAA6CE,kBAAkBK;;MAEvGF"}
+{"version":3,"file":"cache_backed.d.cts","names":["EmbeddingsInterface","Embeddings","BaseStore","AsyncCallerParams","CacheBackedEmbeddingsFields","CacheBackedEmbeddings","Promise","Uint8Array"],"sources":["../../src/embeddings/cache_backed.d.ts"],"sourcesContent":["import { type EmbeddingsInterface, Embeddings } from \"@langchain/core/embeddings\";\nimport { BaseStore } from \"@langchain/core/stores\";\nimport { AsyncCallerParams } from \"@langchain/core/utils/async_caller\";\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 * 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 declare class CacheBackedEmbeddings extends Embeddings {\n    protected underlyingEmbeddings: EmbeddingsInterface;\n    protected documentEmbeddingStore: BaseStore<string, number[]>;\n    constructor(fields: CacheBackedEmbeddingsFields);\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    embedQuery(document: string): Promise<number[]>;\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    embedDocuments(documents: string[]): Promise<number[][]>;\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(underlyingEmbeddings: EmbeddingsInterface, documentEmbeddingStore: BaseStore<string, Uint8Array>, options?: {\n        namespace?: string;\n    }): CacheBackedEmbeddings;\n}\n//# sourceMappingURL=cache_backed.d.ts.map"],"mappings":";;;;;;;;AAOA;;AAE4BE,UAFXE,2BAAAA,SAAoCD,iBAEzBD,CAAAA;EAFyBC,oBAAAA,EAC3BH,mBAD2BG;EAAiB,sBAAA,EAE1CD,SAF0C,CAAA,MAAA,EAAA,MAAA,EAAA,CAAA;AAmDtE;;;;;;;;;;;AAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAxCG,qBAAAA,SAA8BJ,UAAAA;kCACfD;oCACEE;sBACdE;;;;;;;;;;;;;;;;gCAgBUE;;;;;;;;;;;uCAWOA;;;;;;;;;8CASON,6CAA6CE,kBAAkBK;;MAEvGF"}

package/dist/embeddings/cache_backed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache_backed.d.ts","names":["EmbeddingsInterface","Embeddings","BaseStore","AsyncCallerParams","CacheBackedEmbeddingsFields","CacheBackedEmbeddings","Promise","Uint8Array"],"sources":["../../src/embeddings/cache_backed.d.ts"],"sourcesContent":["import { type EmbeddingsInterface, Embeddings } from \"@langchain/core/embeddings\";\nimport { BaseStore } from \"@langchain/core/stores\";\nimport { AsyncCallerParams } from \"@langchain/core/utils/async_caller\";\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 * 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 declare class CacheBackedEmbeddings extends Embeddings {\n    protected underlyingEmbeddings: EmbeddingsInterface;\n    protected documentEmbeddingStore: BaseStore<string, number[]>;\n    constructor(fields: CacheBackedEmbeddingsFields);\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    embedQuery(document: string): Promise<number[]>;\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    embedDocuments(documents: string[]): Promise<number[][]>;\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(underlyingEmbeddings: EmbeddingsInterface, documentEmbeddingStore: BaseStore<string, Uint8Array>, options?: {\n        namespace?: string;\n    }): CacheBackedEmbeddings;\n}\n"],"mappings":";;;;;;;;AAOA;;AAC0BA,UADTI,2BAAAA,SAAoCD,iBAC3BH,CAAAA;EAAmB,oBACjBE,EADFF,mBACEE;EAAS,sBAFgBC,EAEzBD,SAFyBC,CAAAA,MAAAA,EAAAA,MAAAA,EAAAA,CAAAA;AAAiB;AAmDtE;;;;;;;;;;;;AAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAxCE,qBAAAA,SAA8BJ,UAAAA;kCACfD;oCACEE;sBACdE;;;;;;;;;;;;;;;;gCAgBUE;;;;;;;;;;;uCAWOA;;;;;;;;;8CASON,6CAA6CE,kBAAkBK;;MAEvGF"}
+{"version":3,"file":"cache_backed.d.ts","names":["EmbeddingsInterface","Embeddings","BaseStore","AsyncCallerParams","CacheBackedEmbeddingsFields","CacheBackedEmbeddings","Promise","Uint8Array"],"sources":["../../src/embeddings/cache_backed.d.ts"],"sourcesContent":["import { type EmbeddingsInterface, Embeddings } from \"@langchain/core/embeddings\";\nimport { BaseStore } from \"@langchain/core/stores\";\nimport { AsyncCallerParams } from \"@langchain/core/utils/async_caller\";\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 * 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 declare class CacheBackedEmbeddings extends Embeddings {\n    protected underlyingEmbeddings: EmbeddingsInterface;\n    protected documentEmbeddingStore: BaseStore<string, number[]>;\n    constructor(fields: CacheBackedEmbeddingsFields);\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    embedQuery(document: string): Promise<number[]>;\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    embedDocuments(documents: string[]): Promise<number[][]>;\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(underlyingEmbeddings: EmbeddingsInterface, documentEmbeddingStore: BaseStore<string, Uint8Array>, options?: {\n        namespace?: string;\n    }): CacheBackedEmbeddings;\n}\n//# sourceMappingURL=cache_backed.d.ts.map"],"mappings":";;;;;;;;AAOA;;AAE4BE,UAFXE,2BAAAA,SAAoCD,iBAEzBD,CAAAA;EAFyBC,oBAAAA,EAC3BH,mBAD2BG;EAAiB,sBAAA,EAE1CD,SAF0C,CAAA,MAAA,EAAA,MAAA,EAAA,CAAA;AAmDtE;;;;;;;;;;;AAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAxCG,qBAAAA,SAA8BJ,UAAAA;kCACfD;oCACEE;sBACdE;;;;;;;;;;;;;;;;gCAgBUE;;;;;;;;;;;uCAWOA;;;;;;;;;8CASON,6CAA6CE,kBAAkBK;;MAEvGF"}

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

@@ -0,0 +1 @@
+import { TrajectoryEvalChain, TrajectoryOutputParser } from "./trajectory.js";

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

@@ -1,10 +1,10 @@
-import { BasePromptValueInterface } from "../../langchain-core/dist/prompt_values.cjs";
 import { AgentTrajectoryEvaluator, EvalOutputType, ExtractLLMCallOptions, LLMEvalChainInput, LLMTrajectoryEvaluatorArgs } from "../base.cjs";
 import { AgentStep } from "@langchain/core/agents";
 import { ChatGeneration, Generation } from "@langchain/core/outputs";
 import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
 import { ChainValues } from "@langchain/core/utils/types";
 import { BasePromptTemplate } from "@langchain/core/prompts";
+import * as _langchain_core_prompt_values5 from "@langchain/core/prompt_values";
 import { BaseCallbackConfig, Callbacks } from "@langchain/core/callbacks/manager";
 import { StructuredToolInterface } from "@langchain/core/tools";
 import { BaseChatModel } from "@langchain/core/language_models/chat_models";
@@ -31,7 +31,7 @@ declare class TrajectoryEvalChain extends AgentTrajectoryEvaluator {
   requiresInput: boolean;
   requiresReference: boolean;
   outputParser: TrajectoryOutputParser;
-  static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredToolInterface[]): BasePromptTemplate<any, BasePromptValueInterface, any>;
+  static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredToolInterface[]): BasePromptTemplate<any, _langchain_core_prompt_values5.BasePromptValueInterface, any>;
   /**
    * Get the description of the agent tools.
    *

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_js3","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_prompt_values5","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/prompt_values\").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//# sourceMappingURL=trajectory.d.ts.map"],"mappings":";;;;;;;;;;;;;;;AAYqBe,cAAAA,sBAAAA,SAA+Bd,mBAAT,CAA6BU,cAA7B,CAAA,CAAA;EAA6BA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAG3CN,YAAAA,EAAAA,MAAAA,EAAAA;EAAeD,WAAAA,CAAAA,WAAAA,EAAfC,UAAeD,EAAAA,GAAAA,cAAAA,EAAAA,EAAAA,UAAAA,EAA8BG,SAA9BH,GAAAA,SAAAA,CAAAA,EAAsDY,OAAtDZ,CAA8DO,cAA9DP,CAAAA;;;;;AAH2B;AAWvE;;AAO4CE,cAPvBW,mBAAAA,SAA4BP,wBAAAA,CAOLJ;EAA6CN,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAuBkB,aAAAA,CAAAA,EAAAA,MAAAA;EAAKZ,cAAAA,CAAAA,EAAAA,MAAAA;EAM7EN,aAAAA,EAAAA,OAAAA;EAOhBS,iBAAAA,EAAAA,OAAAA;EAA4BT,YAAAA,EAdlCe,sBAckCf;EAAuDY,OAAAA,uBAAAA,CAAAA,MAAAA,CAAAA,EAb/DN,kBAa+DM,GAAAA,SAAAA,EAAAA,UAAAA,CAAAA,EAblBZ,uBAakBY,EAAAA,CAAAA,EAbUN,kBAaVM,CAAAA,GAAAA,EAbKM,8BAAAA,CAAqEC,wBAAAA,EAa1EP,GAAAA,CAAAA;EAALQ;;;;;EAQxElB,OAAAA,gBAAAA,CAAAA,UAAAA,EAfUF,uBAeVE,EAAAA,CAAAA,EAAAA,MAAAA;EAEKW;;;;;;EA9BcH,OAAAA,OAAAA,CAAAA,GAAAA,EAoBzBD,aApByBC,EAAAA,UAAAA,CAAAA,EAoBGV,uBApBHU,EAAAA,EAAAA,YAAAA,CAAAA,EAoB6CW,OApB7CX,CAoBqDU,IApBrDV,CAoB0DE,iBApB1DF,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAoBuFM,OApBvFN,CAoB+FO,mBApB/FP,CAAAA;EAAwB,cAAA,CAAA,MAAA,EAqB9CP,WArB8C,CAAA,EAAA,GAAA;;;;;;;4BA4B3CD;;iCAEKW,yCAAyCC,6CAA6CP,YAAYC,qBAAqBQ,QAAQb"}

package/dist/evaluation/agents/trajectory.d.ts

@@ -1,4 +1,3 @@
-import { BasePromptValueInterface } from "../../libs/langchain-core/dist/prompt_values.js";
 import { AgentTrajectoryEvaluator, EvalOutputType, ExtractLLMCallOptions, LLMEvalChainInput, LLMTrajectoryEvaluatorArgs } from "../base.js";
 import { BasePromptTemplate } from "@langchain/core/prompts";
 import { StructuredToolInterface } from "@langchain/core/tools";
@@ -7,6 +6,7 @@ import { BaseCallbackConfig, Callbacks } from "@langchain/core/callbacks/manager
 import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
 import { ChainValues } from "@langchain/core/utils/types";
 import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import * as _langchain_core_prompt_values1 from "@langchain/core/prompt_values";
 import { AgentStep } from "@langchain/core/agents";
 
 //#region src/evaluation/agents/trajectory.d.ts
@@ -31,7 +31,7 @@ declare class TrajectoryEvalChain extends AgentTrajectoryEvaluator {
   requiresInput: boolean;
   requiresReference: boolean;
   outputParser: TrajectoryOutputParser;
-  static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredToolInterface[]): BasePromptTemplate<any, BasePromptValueInterface, any>;
+  static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredToolInterface[]): BasePromptTemplate<any, _langchain_core_prompt_values1.BasePromptValueInterface, any>;
   /**
    * Get the description of the agent tools.
    *

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

@@ -1 +1 @@
-{"version":3,"file":"trajectory.d.ts","names":["StructuredToolInterface","BaseLLMOutputParser","AgentStep","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","BaseChatModel","AgentTrajectoryEvaluator","EvalOutputType","LLMEvalChainInput","LLMTrajectoryEvaluatorArgs","ExtractLLMCallOptions","TrajectoryOutputParser","Promise","TrajectoryEvalChain","____________langchain_core_dist_prompt_values_js3","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.ts","names":["StructuredToolInterface","BaseLLMOutputParser","AgentStep","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","BaseChatModel","AgentTrajectoryEvaluator","EvalOutputType","LLMEvalChainInput","LLMTrajectoryEvaluatorArgs","ExtractLLMCallOptions","TrajectoryOutputParser","Promise","TrajectoryEvalChain","_langchain_core_prompt_values1","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/prompt_values\").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//# sourceMappingURL=trajectory.d.ts.map"],"mappings":";;;;;;;;;;;;;;;AAYqBe,cAAAA,sBAAAA,SAA+Bd,mBAAT,CAA6BU,cAA7B,CAAA,CAAA;EAA6BA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAG3CN,YAAAA,EAAAA,MAAAA,EAAAA;EAAeD,WAAAA,CAAAA,WAAAA,EAAfC,UAAeD,EAAAA,GAAAA,cAAAA,EAAAA,EAAAA,UAAAA,EAA8BG,SAA9BH,GAAAA,SAAAA,CAAAA,EAAsDY,OAAtDZ,CAA8DO,cAA9DP,CAAAA;;;;;AAH2B;AAWvE;;AAO4CE,cAPvBW,mBAAAA,SAA4BP,wBAAAA,CAOLJ;EAA6CN,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAuBkB,aAAAA,CAAAA,EAAAA,MAAAA;EAAKZ,cAAAA,CAAAA,EAAAA,MAAAA;EAM7EN,aAAAA,EAAAA,OAAAA;EAOhBS,iBAAAA,EAAAA,OAAAA;EAA4BT,YAAAA,EAdlCe,sBAckCf;EAAuDY,OAAAA,uBAAAA,CAAAA,MAAAA,CAAAA,EAb/DN,kBAa+DM,GAAAA,SAAAA,EAAAA,UAAAA,CAAAA,EAblBZ,uBAakBY,EAAAA,CAAAA,EAbUN,kBAaVM,CAAAA,GAAAA,EAbKM,8BAAAA,CAAqEC,wBAAAA,EAa1EP,GAAAA,CAAAA;EAALQ;;;;;EAQxElB,OAAAA,gBAAAA,CAAAA,UAAAA,EAfUF,uBAeVE,EAAAA,CAAAA,EAAAA,MAAAA;EAEKW;;;;;;EA9BcH,OAAAA,OAAAA,CAAAA,GAAAA,EAoBzBD,aApByBC,EAAAA,UAAAA,CAAAA,EAoBGV,uBApBHU,EAAAA,EAAAA,YAAAA,CAAAA,EAoB6CW,OApB7CX,CAoBqDU,IApBrDV,CAoB0DE,iBApB1DF,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAoBuFM,OApBvFN,CAoB+FO,mBApB/FP,CAAAA;EAAwB,cAAA,CAAA,MAAA,EAqB9CP,WArB8C,CAAA,EAAA,GAAA;;;;;;;4BA4B3CD;;iCAEKW,yCAAyCC,6CAA6CP,YAAYC,qBAAqBQ,QAAQb"}

package/dist/evaluation/base.d.cts

@@ -10,16 +10,7 @@ import { BaseCallbackConfig, Callbacks } from "@langchain/core/callbacks/manager
  * Base input for evaluators.
  */
 interface LLMEvalChainInput<T extends EvalOutputType = EvalOutputType, L extends BaseLanguageModelInterface = BaseLanguageModelInterface> extends LLMChainInput<T, L> {}
-type ExtractLLMCallOptions<LanguageModelInterface> = LanguageModelInterface extends BaseLanguageModelInterface<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-any, infer CallOptions> ? CallOptions : never;
-/**
- * Compare two sets for equality
- *
- * @param xs
- * @param ys
- */
-
+type ExtractLLMCallOptions<LanguageModelInterface> = LanguageModelInterface extends BaseLanguageModelInterface<any, infer CallOptions> ? CallOptions : never;
 /**
  * The type of the output of an evaluation evaluator.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"base.d.cts","names":["BaseLanguageModelInterface","AgentStep","ChainValues","BaseCallbackConfig","Callbacks","BaseChain","LLMChain","LLMChainInput","LLMEvalChainInput","EvalOutputType","T","L","ExtractLLMCallOptions","LanguageModelInterface","CallOptions","eqSet","Set","Record","LLMEvalChain","EvalChain","RunInput","RunOutput","StringEvaluatorArgs","PairwiseStringEvaluatorArgs","LLMPairwiseStringEvaluatorArgs","LLMTrajectoryEvaluatorArgs","LLMStringEvaluator","Promise","StringEvaluator","PairwiseStringEvaluator","LLMPairwiseStringEvaluator","AgentTrajectoryEvaluator"],"sources":["../../src/evaluation/base.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { BaseCallbackConfig, Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { BaseChain, LLMChain, LLMChainInput } from \"../chains/index.js\";\n/**\n * Base input for evaluators.\n */\nexport interface LLMEvalChainInput<T extends EvalOutputType = EvalOutputType, L extends BaseLanguageModelInterface = BaseLanguageModelInterface> extends LLMChainInput<T, L> {\n}\nexport type ExtractLLMCallOptions<LanguageModelInterface> = LanguageModelInterface extends BaseLanguageModelInterface<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nany, infer CallOptions> ? CallOptions : never;\n/**\n * Compare two sets for equality\n *\n * @param xs\n * @param ys\n */\nexport declare const eqSet: (xs: Set<string>, ys: Set<string>) => boolean;\n/**\n * The type of the output of an evaluation evaluator.\n */\nexport type EvalOutputType = Record<string, string | number | boolean>;\n/**\n * Base llm chain class for evaluators.\n */\nexport declare abstract class LLMEvalChain<T extends EvalOutputType = EvalOutputType, L extends BaseLanguageModelInterface = BaseLanguageModelInterface> extends LLMChain<T, L> {\n    requiresInput?: boolean;\n    requiresReference?: boolean;\n    skipInputWarning?: string;\n    skipReferenceWarning?: string;\n    /**\n     * Check if the evaluation arguments are valid.\n     * @param reference  The reference label.\n     * @param input The input string.\n     * @throws {Error} If the evaluator requires an input string but none is provided, or if the evaluator requires a reference label but none is provided.\n     */\n    checkEvaluationArgs(reference?: string, input?: string): void;\n}\n/**\n * Base chain class for evaluators.\n */\nexport declare abstract class EvalChain<RunInput extends ChainValues = ChainValues, RunOutput extends ChainValues = ChainValues> extends BaseChain<RunInput, RunOutput> {\n    requiresInput?: boolean;\n    requiresReference?: boolean;\n    skipInputWarning?: string;\n    skipReferenceWarning?: string;\n    /**\n     * Check if the evaluation arguments are valid.\n     * @param reference  The reference label.\n     * @param input The input string.\n     * @throws {Error} If the evaluator requires an input string but none is provided, or if the evaluator requires a reference label but none is provided.\n     */\n    checkEvaluationArgs(reference?: string, input?: string): void;\n}\n/**\n * @field prediction The output string from the  model.\n * @field reference The expected output / reference string.\n * @field input The input string.\n */\nexport interface StringEvaluatorArgs {\n    prediction: string;\n    reference?: string;\n    input?: string;\n}\n/**\n * @field prediction The output string from the first model.\n * @field predictionB The output string from the second model.\n */\nexport interface PairwiseStringEvaluatorArgs {\n    prediction: string;\n    predictionB: string;\n}\n/**\n * @field The input string.\n * @field prediction The output string from the first model.\n * @field predictionB The output string from the second model.\n * @field reference The expected output / reference string.\n */\nexport interface LLMPairwiseStringEvaluatorArgs {\n    input: string;\n    prediction: string;\n    predictionB: string;\n    reference?: string;\n}\n/**\n * Args for AgentTrajectoryEvaluator\n * @field input The input to the agent.\n * @field prediction The final predicted response.\n * @field reference The reference answer.\n * @field agentTrajectory  The intermediate steps forming the agent trajectory.\n */\nexport interface LLMTrajectoryEvaluatorArgs {\n    input: string;\n    prediction: string;\n    reference?: string;\n    agentTrajectory: AgentStep[];\n}\n/**\n * Grade, tag, or otherwise evaluate predictions relative to their inputs\n * and/or reference labels\n */\nexport declare abstract class LLMStringEvaluator<T extends EvalOutputType = EvalOutputType, L extends BaseLanguageModelInterface = BaseLanguageModelInterface> extends LLMEvalChain<T, L> {\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate Chain or LLM output, based on optional input and label.\n     * @returns The evaluation results containing the score or value. It is recommended that the dictionary contain the following keys:\n     * - score: the score of the evaluation, if applicable.\n     * - value: the string value of the evaluation, if applicable.\n     * - reasoning: the reasoning for the evaluation, if applicable.\n     * @param args\n     * @param callOptions\n     * @param config\n     */\n    abstract _evaluateStrings(args: StringEvaluatorArgs & ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate Chain or LLM output, based on optional input and label.\n     * @returns The evaluation results containing the score or value. It is recommended that the dictionary contain the following keys:\n     * - score: the score of the evaluation, if applicable.\n     * - value: the string value of the evaluation, if applicable.\n     * - reasoning: the reasoning for the evaluation, if applicable.\n     * @param args\n     * @param callOptions\n     * @param config\n     */\n    evaluateStrings(args: StringEvaluatorArgs & ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Grade, tag, or otherwise evaluate predictions relative to their inputs\n * and/or reference labels\n */\nexport declare abstract class StringEvaluator extends EvalChain {\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate Chain or LLM output, based on optional input and label.\n     * @returns The evaluation results containing the score or value. It is recommended that the dictionary contain the following keys:\n     * - score: the score of the evaluation, if applicable.\n     * - value: the string value of the evaluation, if applicable.\n     * - reasoning: the reasoning for the evaluation, if applicable.\n     * @param args\n     * @param config\n     */\n    abstract _evaluateStrings(args: StringEvaluatorArgs, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate Chain or LLM output, based on optional input and label.\n     * @returns The evaluation results containing the score or value. It is recommended that the dictionary contain the following keys:\n     * - score: the score of the evaluation, if applicable.\n     * - value: the string value of the evaluation, if applicable.\n     * - reasoning: the reasoning for the evaluation, if applicable.\n     * @param args\n     * @param config\n     */\n    evaluateStrings(args: StringEvaluatorArgs, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Compare the output of two models (or two outputs of the same model).\n */\nexport declare abstract class PairwiseStringEvaluator extends EvalChain {\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate the output string pairs.\n     * @param args\n     * @param config\n     * @return A dictionary containing the preference, scores, and/or other information.\n     */\n    abstract _evaluateStringPairs(args: PairwiseStringEvaluatorArgs, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate the output string pairs.\n     * @param args\n     * @param config\n     * @return A dictionary containing the preference, scores, and/or other information.\n     */\n    evaluateStringPairs(args: PairwiseStringEvaluatorArgs, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Compare the output of two models (or two outputs of the same model).\n */\nexport declare abstract class LLMPairwiseStringEvaluator extends LLMEvalChain {\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate the output string pairs.\n     * @param args\n     * @param callOptions\n     * @param config\n     * @return A dictionary containing the preference, scores, and/or other information.\n     */\n    abstract _evaluateStringPairs(args: LLMPairwiseStringEvaluatorArgs, callOptions?: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate the output string pairs.\n     * @param args\n     * @param callOptions\n     * @param config\n     * @return A dictionary containing the preference, scores, and/or other information.\n     */\n    evaluateStringPairs(args: LLMPairwiseStringEvaluatorArgs, callOptions?: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Interface for evaluating agent trajectories.\n */\nexport declare abstract class AgentTrajectoryEvaluator extends LLMEvalChain {\n    requiresInput: boolean;\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate a trajectory.\n     * @return The evaluation result.\n     * @param args\n     * @param callOptions\n     * @param config\n     */\n    abstract _evaluateAgentTrajectory(args: LLMTrajectoryEvaluatorArgs, callOptions?: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate a trajectory.\n     * @return The evaluation result.\n     * @param args\n     * @param callOptions\n     * @param config\n     */\n    evaluateAgentTrajectory(args: LLMTrajectoryEvaluatorArgs, callOptions?: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n"],"mappings":"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"}
+{"version":3,"file":"base.d.cts","names":["BaseLanguageModelInterface","AgentStep","ChainValues","BaseCallbackConfig","Callbacks","BaseChain","LLMChain","LLMChainInput","LLMEvalChainInput","T","L","EvalOutputType","ExtractLLMCallOptions","LanguageModelInterface","CallOptions","eqSet","Set","Record","LLMEvalChain","EvalChain","RunInput","RunOutput","StringEvaluatorArgs","PairwiseStringEvaluatorArgs","LLMPairwiseStringEvaluatorArgs","LLMTrajectoryEvaluatorArgs","LLMStringEvaluator","Promise","StringEvaluator","PairwiseStringEvaluator","LLMPairwiseStringEvaluator","AgentTrajectoryEvaluator"],"sources":["../../src/evaluation/base.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { BaseCallbackConfig, Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { BaseChain, LLMChain, LLMChainInput } from \"../chains/index.js\";\n/**\n * Base input for evaluators.\n */\nexport interface LLMEvalChainInput<T extends EvalOutputType = EvalOutputType, L extends BaseLanguageModelInterface = BaseLanguageModelInterface> extends LLMChainInput<T, L> {\n}\nexport type ExtractLLMCallOptions<LanguageModelInterface> = LanguageModelInterface extends BaseLanguageModelInterface<any, infer CallOptions> ? CallOptions : never;\n/**\n * Compare two sets for equality\n *\n * @param xs\n * @param ys\n */\nexport declare const eqSet: (xs: Set<string>, ys: Set<string>) => boolean;\n/**\n * The type of the output of an evaluation evaluator.\n */\nexport type EvalOutputType = Record<string, string | number | boolean>;\n/**\n * Base llm chain class for evaluators.\n */\nexport declare abstract class LLMEvalChain<T extends EvalOutputType = EvalOutputType, L extends BaseLanguageModelInterface = BaseLanguageModelInterface> extends LLMChain<T, L> {\n    requiresInput?: boolean;\n    requiresReference?: boolean;\n    skipInputWarning?: string;\n    skipReferenceWarning?: string;\n    /**\n     * Check if the evaluation arguments are valid.\n     * @param reference  The reference label.\n     * @param input The input string.\n     * @throws {Error} If the evaluator requires an input string but none is provided, or if the evaluator requires a reference label but none is provided.\n     */\n    checkEvaluationArgs(reference?: string, input?: string): void;\n}\n/**\n * Base chain class for evaluators.\n */\nexport declare abstract class EvalChain<RunInput extends ChainValues = ChainValues, RunOutput extends ChainValues = ChainValues> extends BaseChain<RunInput, RunOutput> {\n    requiresInput?: boolean;\n    requiresReference?: boolean;\n    skipInputWarning?: string;\n    skipReferenceWarning?: string;\n    /**\n     * Check if the evaluation arguments are valid.\n     * @param reference  The reference label.\n     * @param input The input string.\n     * @throws {Error} If the evaluator requires an input string but none is provided, or if the evaluator requires a reference label but none is provided.\n     */\n    checkEvaluationArgs(reference?: string, input?: string): void;\n}\n/**\n * @field prediction The output string from the  model.\n * @field reference The expected output / reference string.\n * @field input The input string.\n */\nexport interface StringEvaluatorArgs {\n    prediction: string;\n    reference?: string;\n    input?: string;\n}\n/**\n * @field prediction The output string from the first model.\n * @field predictionB The output string from the second model.\n */\nexport interface PairwiseStringEvaluatorArgs {\n    prediction: string;\n    predictionB: string;\n}\n/**\n * @field The input string.\n * @field prediction The output string from the first model.\n * @field predictionB The output string from the second model.\n * @field reference The expected output / reference string.\n */\nexport interface LLMPairwiseStringEvaluatorArgs {\n    input: string;\n    prediction: string;\n    predictionB: string;\n    reference?: string;\n}\n/**\n * Args for AgentTrajectoryEvaluator\n * @field input The input to the agent.\n * @field prediction The final predicted response.\n * @field reference The reference answer.\n * @field agentTrajectory  The intermediate steps forming the agent trajectory.\n */\nexport interface LLMTrajectoryEvaluatorArgs {\n    input: string;\n    prediction: string;\n    reference?: string;\n    agentTrajectory: AgentStep[];\n}\n/**\n * Grade, tag, or otherwise evaluate predictions relative to their inputs\n * and/or reference labels\n */\nexport declare abstract class LLMStringEvaluator<T extends EvalOutputType = EvalOutputType, L extends BaseLanguageModelInterface = BaseLanguageModelInterface> extends LLMEvalChain<T, L> {\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate Chain or LLM output, based on optional input and label.\n     * @returns The evaluation results containing the score or value. It is recommended that the dictionary contain the following keys:\n     * - score: the score of the evaluation, if applicable.\n     * - value: the string value of the evaluation, if applicable.\n     * - reasoning: the reasoning for the evaluation, if applicable.\n     * @param args\n     * @param callOptions\n     * @param config\n     */\n    abstract _evaluateStrings(args: StringEvaluatorArgs & ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate Chain or LLM output, based on optional input and label.\n     * @returns The evaluation results containing the score or value. It is recommended that the dictionary contain the following keys:\n     * - score: the score of the evaluation, if applicable.\n     * - value: the string value of the evaluation, if applicable.\n     * - reasoning: the reasoning for the evaluation, if applicable.\n     * @param args\n     * @param callOptions\n     * @param config\n     */\n    evaluateStrings(args: StringEvaluatorArgs & ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Grade, tag, or otherwise evaluate predictions relative to their inputs\n * and/or reference labels\n */\nexport declare abstract class StringEvaluator extends EvalChain {\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate Chain or LLM output, based on optional input and label.\n     * @returns The evaluation results containing the score or value. It is recommended that the dictionary contain the following keys:\n     * - score: the score of the evaluation, if applicable.\n     * - value: the string value of the evaluation, if applicable.\n     * - reasoning: the reasoning for the evaluation, if applicable.\n     * @param args\n     * @param config\n     */\n    abstract _evaluateStrings(args: StringEvaluatorArgs, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate Chain or LLM output, based on optional input and label.\n     * @returns The evaluation results containing the score or value. It is recommended that the dictionary contain the following keys:\n     * - score: the score of the evaluation, if applicable.\n     * - value: the string value of the evaluation, if applicable.\n     * - reasoning: the reasoning for the evaluation, if applicable.\n     * @param args\n     * @param config\n     */\n    evaluateStrings(args: StringEvaluatorArgs, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Compare the output of two models (or two outputs of the same model).\n */\nexport declare abstract class PairwiseStringEvaluator extends EvalChain {\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate the output string pairs.\n     * @param args\n     * @param config\n     * @return A dictionary containing the preference, scores, and/or other information.\n     */\n    abstract _evaluateStringPairs(args: PairwiseStringEvaluatorArgs, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate the output string pairs.\n     * @param args\n     * @param config\n     * @return A dictionary containing the preference, scores, and/or other information.\n     */\n    evaluateStringPairs(args: PairwiseStringEvaluatorArgs, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Compare the output of two models (or two outputs of the same model).\n */\nexport declare abstract class LLMPairwiseStringEvaluator extends LLMEvalChain {\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate the output string pairs.\n     * @param args\n     * @param callOptions\n     * @param config\n     * @return A dictionary containing the preference, scores, and/or other information.\n     */\n    abstract _evaluateStringPairs(args: LLMPairwiseStringEvaluatorArgs, callOptions?: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate the output string pairs.\n     * @param args\n     * @param callOptions\n     * @param config\n     * @return A dictionary containing the preference, scores, and/or other information.\n     */\n    evaluateStringPairs(args: LLMPairwiseStringEvaluatorArgs, callOptions?: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Interface for evaluating agent trajectories.\n */\nexport declare abstract class AgentTrajectoryEvaluator extends LLMEvalChain {\n    requiresInput: boolean;\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate a trajectory.\n     * @return The evaluation result.\n     * @param args\n     * @param callOptions\n     * @param config\n     */\n    abstract _evaluateAgentTrajectory(args: LLMTrajectoryEvaluatorArgs, callOptions?: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate a trajectory.\n     * @return The evaluation result.\n     * @param args\n     * @param callOptions\n     * @param config\n     */\n    evaluateAgentTrajectory(args: LLMTrajectoryEvaluatorArgs, callOptions?: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":"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"}

package/dist/evaluation/base.d.ts

@@ -1,5 +1,6 @@
 import { BaseChain } from "../chains/base.js";
 import { LLMChain, LLMChainInput } from "../chains/llm_chain.js";
+import "../chains/index.js";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
 import { BaseCallbackConfig, Callbacks } from "@langchain/core/callbacks/manager";
 import { ChainValues } from "@langchain/core/utils/types";
@@ -10,16 +11,7 @@ import { AgentStep } from "@langchain/core/agents";
  * Base input for evaluators.
  */
 interface LLMEvalChainInput<T extends EvalOutputType = EvalOutputType, L extends BaseLanguageModelInterface = BaseLanguageModelInterface> extends LLMChainInput<T, L> {}
-type ExtractLLMCallOptions<LanguageModelInterface> = LanguageModelInterface extends BaseLanguageModelInterface<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-any, infer CallOptions> ? CallOptions : never;
-/**
- * Compare two sets for equality
- *
- * @param xs
- * @param ys
- */
-
+type ExtractLLMCallOptions<LanguageModelInterface> = LanguageModelInterface extends BaseLanguageModelInterface<any, infer CallOptions> ? CallOptions : never;
 /**
  * The type of the output of an evaluation evaluator.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","names":["BaseLanguageModelInterface","AgentStep","ChainValues","BaseCallbackConfig","Callbacks","BaseChain","LLMChain","LLMChainInput","LLMEvalChainInput","EvalOutputType","T","L","ExtractLLMCallOptions","LanguageModelInterface","CallOptions","eqSet","Set","Record","LLMEvalChain","EvalChain","RunInput","RunOutput","StringEvaluatorArgs","PairwiseStringEvaluatorArgs","LLMPairwiseStringEvaluatorArgs","LLMTrajectoryEvaluatorArgs","LLMStringEvaluator","Promise","StringEvaluator","PairwiseStringEvaluator","LLMPairwiseStringEvaluator","AgentTrajectoryEvaluator"],"sources":["../../src/evaluation/base.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { BaseCallbackConfig, Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { BaseChain, LLMChain, LLMChainInput } from \"../chains/index.js\";\n/**\n * Base input for evaluators.\n */\nexport interface LLMEvalChainInput<T extends EvalOutputType = EvalOutputType, L extends BaseLanguageModelInterface = BaseLanguageModelInterface> extends LLMChainInput<T, L> {\n}\nexport type ExtractLLMCallOptions<LanguageModelInterface> = LanguageModelInterface extends BaseLanguageModelInterface<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nany, infer CallOptions> ? CallOptions : never;\n/**\n * Compare two sets for equality\n *\n * @param xs\n * @param ys\n */\nexport declare const eqSet: (xs: Set<string>, ys: Set<string>) => boolean;\n/**\n * The type of the output of an evaluation evaluator.\n */\nexport type EvalOutputType = Record<string, string | number | boolean>;\n/**\n * Base llm chain class for evaluators.\n */\nexport declare abstract class LLMEvalChain<T extends EvalOutputType = EvalOutputType, L extends BaseLanguageModelInterface = BaseLanguageModelInterface> extends LLMChain<T, L> {\n    requiresInput?: boolean;\n    requiresReference?: boolean;\n    skipInputWarning?: string;\n    skipReferenceWarning?: string;\n    /**\n     * Check if the evaluation arguments are valid.\n     * @param reference  The reference label.\n     * @param input The input string.\n     * @throws {Error} If the evaluator requires an input string but none is provided, or if the evaluator requires a reference label but none is provided.\n     */\n    checkEvaluationArgs(reference?: string, input?: string): void;\n}\n/**\n * Base chain class for evaluators.\n */\nexport declare abstract class EvalChain<RunInput extends ChainValues = ChainValues, RunOutput extends ChainValues = ChainValues> extends BaseChain<RunInput, RunOutput> {\n    requiresInput?: boolean;\n    requiresReference?: boolean;\n    skipInputWarning?: string;\n    skipReferenceWarning?: string;\n    /**\n     * Check if the evaluation arguments are valid.\n     * @param reference  The reference label.\n     * @param input The input string.\n     * @throws {Error} If the evaluator requires an input string but none is provided, or if the evaluator requires a reference label but none is provided.\n     */\n    checkEvaluationArgs(reference?: string, input?: string): void;\n}\n/**\n * @field prediction The output string from the  model.\n * @field reference The expected output / reference string.\n * @field input The input string.\n */\nexport interface StringEvaluatorArgs {\n    prediction: string;\n    reference?: string;\n    input?: string;\n}\n/**\n * @field prediction The output string from the first model.\n * @field predictionB The output string from the second model.\n */\nexport interface PairwiseStringEvaluatorArgs {\n    prediction: string;\n    predictionB: string;\n}\n/**\n * @field The input string.\n * @field prediction The output string from the first model.\n * @field predictionB The output string from the second model.\n * @field reference The expected output / reference string.\n */\nexport interface LLMPairwiseStringEvaluatorArgs {\n    input: string;\n    prediction: string;\n    predictionB: string;\n    reference?: string;\n}\n/**\n * Args for AgentTrajectoryEvaluator\n * @field input The input to the agent.\n * @field prediction The final predicted response.\n * @field reference The reference answer.\n * @field agentTrajectory  The intermediate steps forming the agent trajectory.\n */\nexport interface LLMTrajectoryEvaluatorArgs {\n    input: string;\n    prediction: string;\n    reference?: string;\n    agentTrajectory: AgentStep[];\n}\n/**\n * Grade, tag, or otherwise evaluate predictions relative to their inputs\n * and/or reference labels\n */\nexport declare abstract class LLMStringEvaluator<T extends EvalOutputType = EvalOutputType, L extends BaseLanguageModelInterface = BaseLanguageModelInterface> extends LLMEvalChain<T, L> {\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate Chain or LLM output, based on optional input and label.\n     * @returns The evaluation results containing the score or value. It is recommended that the dictionary contain the following keys:\n     * - score: the score of the evaluation, if applicable.\n     * - value: the string value of the evaluation, if applicable.\n     * - reasoning: the reasoning for the evaluation, if applicable.\n     * @param args\n     * @param callOptions\n     * @param config\n     */\n    abstract _evaluateStrings(args: StringEvaluatorArgs & ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate Chain or LLM output, based on optional input and label.\n     * @returns The evaluation results containing the score or value. It is recommended that the dictionary contain the following keys:\n     * - score: the score of the evaluation, if applicable.\n     * - value: the string value of the evaluation, if applicable.\n     * - reasoning: the reasoning for the evaluation, if applicable.\n     * @param args\n     * @param callOptions\n     * @param config\n     */\n    evaluateStrings(args: StringEvaluatorArgs & ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Grade, tag, or otherwise evaluate predictions relative to their inputs\n * and/or reference labels\n */\nexport declare abstract class StringEvaluator extends EvalChain {\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate Chain or LLM output, based on optional input and label.\n     * @returns The evaluation results containing the score or value. It is recommended that the dictionary contain the following keys:\n     * - score: the score of the evaluation, if applicable.\n     * - value: the string value of the evaluation, if applicable.\n     * - reasoning: the reasoning for the evaluation, if applicable.\n     * @param args\n     * @param config\n     */\n    abstract _evaluateStrings(args: StringEvaluatorArgs, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate Chain or LLM output, based on optional input and label.\n     * @returns The evaluation results containing the score or value. It is recommended that the dictionary contain the following keys:\n     * - score: the score of the evaluation, if applicable.\n     * - value: the string value of the evaluation, if applicable.\n     * - reasoning: the reasoning for the evaluation, if applicable.\n     * @param args\n     * @param config\n     */\n    evaluateStrings(args: StringEvaluatorArgs, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Compare the output of two models (or two outputs of the same model).\n */\nexport declare abstract class PairwiseStringEvaluator extends EvalChain {\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate the output string pairs.\n     * @param args\n     * @param config\n     * @return A dictionary containing the preference, scores, and/or other information.\n     */\n    abstract _evaluateStringPairs(args: PairwiseStringEvaluatorArgs, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate the output string pairs.\n     * @param args\n     * @param config\n     * @return A dictionary containing the preference, scores, and/or other information.\n     */\n    evaluateStringPairs(args: PairwiseStringEvaluatorArgs, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Compare the output of two models (or two outputs of the same model).\n */\nexport declare abstract class LLMPairwiseStringEvaluator extends LLMEvalChain {\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate the output string pairs.\n     * @param args\n     * @param callOptions\n     * @param config\n     * @return A dictionary containing the preference, scores, and/or other information.\n     */\n    abstract _evaluateStringPairs(args: LLMPairwiseStringEvaluatorArgs, callOptions?: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate the output string pairs.\n     * @param args\n     * @param callOptions\n     * @param config\n     * @return A dictionary containing the preference, scores, and/or other information.\n     */\n    evaluateStringPairs(args: LLMPairwiseStringEvaluatorArgs, callOptions?: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Interface for evaluating agent trajectories.\n */\nexport declare abstract class AgentTrajectoryEvaluator extends LLMEvalChain {\n    requiresInput: boolean;\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate a trajectory.\n     * @return The evaluation result.\n     * @param args\n     * @param callOptions\n     * @param config\n     */\n    abstract _evaluateAgentTrajectory(args: LLMTrajectoryEvaluatorArgs, callOptions?: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate a trajectory.\n     * @return The evaluation result.\n     * @param args\n     * @param callOptions\n     * @param config\n     */\n    evaluateAgentTrajectory(args: LLMTrajectoryEvaluatorArgs, callOptions?: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n"],"mappings":"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"}
+{"version":3,"file":"base.d.ts","names":["BaseLanguageModelInterface","AgentStep","ChainValues","BaseCallbackConfig","Callbacks","BaseChain","LLMChain","LLMChainInput","LLMEvalChainInput","T","L","EvalOutputType","ExtractLLMCallOptions","LanguageModelInterface","CallOptions","eqSet","Set","Record","LLMEvalChain","EvalChain","RunInput","RunOutput","StringEvaluatorArgs","PairwiseStringEvaluatorArgs","LLMPairwiseStringEvaluatorArgs","LLMTrajectoryEvaluatorArgs","LLMStringEvaluator","Promise","StringEvaluator","PairwiseStringEvaluator","LLMPairwiseStringEvaluator","AgentTrajectoryEvaluator"],"sources":["../../src/evaluation/base.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { BaseCallbackConfig, Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { BaseChain, LLMChain, LLMChainInput } from \"../chains/index.js\";\n/**\n * Base input for evaluators.\n */\nexport interface LLMEvalChainInput<T extends EvalOutputType = EvalOutputType, L extends BaseLanguageModelInterface = BaseLanguageModelInterface> extends LLMChainInput<T, L> {\n}\nexport type ExtractLLMCallOptions<LanguageModelInterface> = LanguageModelInterface extends BaseLanguageModelInterface<any, infer CallOptions> ? CallOptions : never;\n/**\n * Compare two sets for equality\n *\n * @param xs\n * @param ys\n */\nexport declare const eqSet: (xs: Set<string>, ys: Set<string>) => boolean;\n/**\n * The type of the output of an evaluation evaluator.\n */\nexport type EvalOutputType = Record<string, string | number | boolean>;\n/**\n * Base llm chain class for evaluators.\n */\nexport declare abstract class LLMEvalChain<T extends EvalOutputType = EvalOutputType, L extends BaseLanguageModelInterface = BaseLanguageModelInterface> extends LLMChain<T, L> {\n    requiresInput?: boolean;\n    requiresReference?: boolean;\n    skipInputWarning?: string;\n    skipReferenceWarning?: string;\n    /**\n     * Check if the evaluation arguments are valid.\n     * @param reference  The reference label.\n     * @param input The input string.\n     * @throws {Error} If the evaluator requires an input string but none is provided, or if the evaluator requires a reference label but none is provided.\n     */\n    checkEvaluationArgs(reference?: string, input?: string): void;\n}\n/**\n * Base chain class for evaluators.\n */\nexport declare abstract class EvalChain<RunInput extends ChainValues = ChainValues, RunOutput extends ChainValues = ChainValues> extends BaseChain<RunInput, RunOutput> {\n    requiresInput?: boolean;\n    requiresReference?: boolean;\n    skipInputWarning?: string;\n    skipReferenceWarning?: string;\n    /**\n     * Check if the evaluation arguments are valid.\n     * @param reference  The reference label.\n     * @param input The input string.\n     * @throws {Error} If the evaluator requires an input string but none is provided, or if the evaluator requires a reference label but none is provided.\n     */\n    checkEvaluationArgs(reference?: string, input?: string): void;\n}\n/**\n * @field prediction The output string from the  model.\n * @field reference The expected output / reference string.\n * @field input The input string.\n */\nexport interface StringEvaluatorArgs {\n    prediction: string;\n    reference?: string;\n    input?: string;\n}\n/**\n * @field prediction The output string from the first model.\n * @field predictionB The output string from the second model.\n */\nexport interface PairwiseStringEvaluatorArgs {\n    prediction: string;\n    predictionB: string;\n}\n/**\n * @field The input string.\n * @field prediction The output string from the first model.\n * @field predictionB The output string from the second model.\n * @field reference The expected output / reference string.\n */\nexport interface LLMPairwiseStringEvaluatorArgs {\n    input: string;\n    prediction: string;\n    predictionB: string;\n    reference?: string;\n}\n/**\n * Args for AgentTrajectoryEvaluator\n * @field input The input to the agent.\n * @field prediction The final predicted response.\n * @field reference The reference answer.\n * @field agentTrajectory  The intermediate steps forming the agent trajectory.\n */\nexport interface LLMTrajectoryEvaluatorArgs {\n    input: string;\n    prediction: string;\n    reference?: string;\n    agentTrajectory: AgentStep[];\n}\n/**\n * Grade, tag, or otherwise evaluate predictions relative to their inputs\n * and/or reference labels\n */\nexport declare abstract class LLMStringEvaluator<T extends EvalOutputType = EvalOutputType, L extends BaseLanguageModelInterface = BaseLanguageModelInterface> extends LLMEvalChain<T, L> {\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate Chain or LLM output, based on optional input and label.\n     * @returns The evaluation results containing the score or value. It is recommended that the dictionary contain the following keys:\n     * - score: the score of the evaluation, if applicable.\n     * - value: the string value of the evaluation, if applicable.\n     * - reasoning: the reasoning for the evaluation, if applicable.\n     * @param args\n     * @param callOptions\n     * @param config\n     */\n    abstract _evaluateStrings(args: StringEvaluatorArgs & ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate Chain or LLM output, based on optional input and label.\n     * @returns The evaluation results containing the score or value. It is recommended that the dictionary contain the following keys:\n     * - score: the score of the evaluation, if applicable.\n     * - value: the string value of the evaluation, if applicable.\n     * - reasoning: the reasoning for the evaluation, if applicable.\n     * @param args\n     * @param callOptions\n     * @param config\n     */\n    evaluateStrings(args: StringEvaluatorArgs & ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Grade, tag, or otherwise evaluate predictions relative to their inputs\n * and/or reference labels\n */\nexport declare abstract class StringEvaluator extends EvalChain {\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate Chain or LLM output, based on optional input and label.\n     * @returns The evaluation results containing the score or value. It is recommended that the dictionary contain the following keys:\n     * - score: the score of the evaluation, if applicable.\n     * - value: the string value of the evaluation, if applicable.\n     * - reasoning: the reasoning for the evaluation, if applicable.\n     * @param args\n     * @param config\n     */\n    abstract _evaluateStrings(args: StringEvaluatorArgs, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate Chain or LLM output, based on optional input and label.\n     * @returns The evaluation results containing the score or value. It is recommended that the dictionary contain the following keys:\n     * - score: the score of the evaluation, if applicable.\n     * - value: the string value of the evaluation, if applicable.\n     * - reasoning: the reasoning for the evaluation, if applicable.\n     * @param args\n     * @param config\n     */\n    evaluateStrings(args: StringEvaluatorArgs, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Compare the output of two models (or two outputs of the same model).\n */\nexport declare abstract class PairwiseStringEvaluator extends EvalChain {\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate the output string pairs.\n     * @param args\n     * @param config\n     * @return A dictionary containing the preference, scores, and/or other information.\n     */\n    abstract _evaluateStringPairs(args: PairwiseStringEvaluatorArgs, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate the output string pairs.\n     * @param args\n     * @param config\n     * @return A dictionary containing the preference, scores, and/or other information.\n     */\n    evaluateStringPairs(args: PairwiseStringEvaluatorArgs, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Compare the output of two models (or two outputs of the same model).\n */\nexport declare abstract class LLMPairwiseStringEvaluator extends LLMEvalChain {\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate the output string pairs.\n     * @param args\n     * @param callOptions\n     * @param config\n     * @return A dictionary containing the preference, scores, and/or other information.\n     */\n    abstract _evaluateStringPairs(args: LLMPairwiseStringEvaluatorArgs, callOptions?: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate the output string pairs.\n     * @param args\n     * @param callOptions\n     * @param config\n     * @return A dictionary containing the preference, scores, and/or other information.\n     */\n    evaluateStringPairs(args: LLMPairwiseStringEvaluatorArgs, callOptions?: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Interface for evaluating agent trajectories.\n */\nexport declare abstract class AgentTrajectoryEvaluator extends LLMEvalChain {\n    requiresInput: boolean;\n    /**\n     * The name of the evaluation.\n     */\n    evaluationName?: string;\n    /**\n     * Evaluate a trajectory.\n     * @return The evaluation result.\n     * @param args\n     * @param callOptions\n     * @param config\n     */\n    abstract _evaluateAgentTrajectory(args: LLMTrajectoryEvaluatorArgs, callOptions?: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /**\n     * Evaluate a trajectory.\n     * @return The evaluation result.\n     * @param args\n     * @param callOptions\n     * @param config\n     */\n    evaluateAgentTrajectory(args: LLMTrajectoryEvaluatorArgs, callOptions?: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":"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"}

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

@@ -0,0 +1 @@
+import { LabeledPairwiseStringEvalChain, PairwiseStringEvalChain, PairwiseStringResultOutputParser } from "./pairwise.js";

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

@@ -1,4 +1,3 @@
-import { BasePromptValueInterface } from "../../langchain-core/dist/prompt_values.cjs";
 import { EvalOutputType, ExtractLLMCallOptions, LLMEvalChainInput, LLMPairwiseStringEvaluator, LLMPairwiseStringEvaluatorArgs } from "../base.cjs";
 import { CriteriaLike } from "../criteria/criteria.cjs";
 import { ChatGeneration, Generation } from "@langchain/core/outputs";
@@ -6,6 +5,7 @@ import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
 import { ChainValues } from "@langchain/core/utils/types";
 import { BasePromptTemplate } from "@langchain/core/prompts";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import * as _langchain_core_prompt_values3 from "@langchain/core/prompt_values";
 import { BaseCallbackConfig, Callbacks } from "@langchain/core/callbacks/manager";
 
 //#region src/evaluation/comparison/pairwise.d.ts
@@ -30,7 +30,7 @@ declare class PairwiseStringEvalChain extends LLMPairwiseStringEvaluator {
   skipReferenceWarning: string;
   outputParser: PairwiseStringResultOutputParser;
   static resolvePairwiseCriteria(criteria?: CriteriaLike): Record<string, string>;
-  static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, BasePromptValueInterface, any>;
+  static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values3.BasePromptValueInterface, any>;
   /**
    * Create a new instance of the PairwiseStringEvalChain.
    * @param llm
@@ -49,7 +49,7 @@ declare class PairwiseStringEvalChain extends LLMPairwiseStringEvaluator {
 declare class LabeledPairwiseStringEvalChain extends PairwiseStringEvalChain {
   static lc_name(): string;
   requiresReference: boolean;
-  static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, BasePromptValueInterface, any>;
+  static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values3.BasePromptValueInterface, any>;
 }
 //#endregion
 export { LabeledPairwiseStringEvalChain, PairwiseStringEvalChain, PairwiseStringResultOutputParser };

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_prompt_values3","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/prompt_values\").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/prompt_values\").BasePromptValueInterface, any>;\n}\n//# sourceMappingURL=pairwise.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAWqBc,cAAAA,gCAAAA,SAAyCb,mBAAT,CAA6BO,cAA7B,CAAA,CAAA;EAA6BA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAGrDJ,YAAAA,EAAAA,MAAAA,EAAAA;EAAeD,WAAAA,CAAAA,WAAAA,EAAfC,UAAeD,EAAAA,GAAAA,cAAAA,EAAAA,EAAAA,UAAAA,EAA8BG,SAA9BH,GAAAA,SAAAA,CAAAA,EAAsDY,OAAtDZ,CAA8DK,cAA9DL,CAAAA;;;;;AAHqC;AAS5Da,cAAAA,uBAAAA,SAAgCN,0BAAAA,CAAT;EAO1BI,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAC4BD,aAAAA,CAAAA,EAAAA,MAAAA;EAAeI,cAAAA,CAAAA,EAAAA,MAAAA;EACnBZ,aAAAA,EAAAA,OAAAA;EAAkBa,iBAAAA,EAAAA,OAAAA;EAAGb,oBAAAA,EAAAA,MAAAA;EAOvCL,YAAAA,EATNc,gCASMd;EAAuCa,OAAAA,uBAAAA,CAAAA,QAAAA,CAAAA,EARjBA,YAQiBA,CAAAA,EARFI,MAQEJ,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAA0CJ,OAAAA,qBAAAA,CAAAA,MAAAA,CAAAA,EAP/DJ,kBAO+DI,CAAAA,EAP1CJ,kBAO0CI,CAAAA,GAAAA,EAP7CS,8BAAAA,CAAmEC,wBAAAA,EAOtBV,GAAAA,CAAAA;EAALW;;;;;;EAExBR,OAAAA,OAAAA,CAAAA,GAAAA,EAFpDZ,0BAEoDY,EAAAA,QAAAA,CAAAA,EAFbC,YAEaD,EAAAA,YAAAA,CAAAA,EAFgBS,OAEhBT,CAFwBQ,IAExBR,CAF6BH,iBAE7BG,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAF0DG,OAE1DH,CAFkEI,uBAElEJ,CAAAA;EAA6CN,cAAAA,CAAAA,MAAAA,EAD9FJ,WAC8FI,CAAAA,EAAAA,GAAAA;EAAYC,oBAAAA,CAAAA,IAAAA,EAAtGI,8BAAsGJ,EAAAA,WAAAA,EAAzDK,qBAAyDL,CAAAA,IAAAA,CAAAA,KAAAA,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAZD,SAAYC,GAAAA,kBAAAA,CAAAA,EAAqBQ,OAArBR,CAA6BL,WAA7BK,CAAAA;;;;AAlBtD;AAyB/E;;AAG4DW,cAHvCI,8BAAAA,SAAuCN,uBAAAA,CAGmEG;EAAhEd,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAHHW,iBAAAA,EAAAA,OAAAA;EAAuB,OAAA,qBAAA,CAAA,MAAA,CAAA,EAGzCX,kBAHyC,CAAA,EAGpBA,kBAHoB,CAAA,GAAA,EAGvBa,8BAAAA,CAAmEC,wBAAAA,EAH5C,GAAA,CAAA"}

package/dist/evaluation/comparison/pairwise.d.ts

@@ -1,4 +1,3 @@
-import { BasePromptValueInterface } from "../../libs/langchain-core/dist/prompt_values.js";
 import { EvalOutputType, ExtractLLMCallOptions, LLMEvalChainInput, LLMPairwiseStringEvaluator, LLMPairwiseStringEvaluatorArgs } from "../base.js";
 import { CriteriaLike } from "../criteria/criteria.js";
 import { BasePromptTemplate } from "@langchain/core/prompts";
@@ -7,6 +6,7 @@ import { ChatGeneration, Generation } from "@langchain/core/outputs";
 import { BaseCallbackConfig, Callbacks } from "@langchain/core/callbacks/manager";
 import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
 import { ChainValues } from "@langchain/core/utils/types";
+import * as _langchain_core_prompt_values2 from "@langchain/core/prompt_values";
 
 //#region src/evaluation/comparison/pairwise.d.ts
 /**
@@ -30,7 +30,7 @@ declare class PairwiseStringEvalChain extends LLMPairwiseStringEvaluator {
   skipReferenceWarning: string;
   outputParser: PairwiseStringResultOutputParser;
   static resolvePairwiseCriteria(criteria?: CriteriaLike): Record<string, string>;
-  static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, BasePromptValueInterface, any>;
+  static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values2.BasePromptValueInterface, any>;
   /**
    * Create a new instance of the PairwiseStringEvalChain.
    * @param llm
@@ -49,7 +49,7 @@ declare class PairwiseStringEvalChain extends LLMPairwiseStringEvaluator {
 declare class LabeledPairwiseStringEvalChain extends PairwiseStringEvalChain {
   static lc_name(): string;
   requiresReference: boolean;
-  static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, BasePromptValueInterface, any>;
+  static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values2.BasePromptValueInterface, any>;
 }
 //#endregion
 export { LabeledPairwiseStringEvalChain, PairwiseStringEvalChain, PairwiseStringResultOutputParser };

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

@@ -1 +1 @@
-{"version":3,"file":"pairwise.d.ts","names":["BaseLanguageModelInterface","BaseLLMOutputParser","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","EvalOutputType","LLMEvalChainInput","LLMPairwiseStringEvaluator","LLMPairwiseStringEvaluatorArgs","ExtractLLMCallOptions","CriteriaLike","PairwiseStringResultOutputParser","Promise","PairwiseStringEvalChain","Record","____________langchain_core_dist_prompt_values_js1","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.ts","names":["BaseLanguageModelInterface","BaseLLMOutputParser","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","EvalOutputType","LLMEvalChainInput","LLMPairwiseStringEvaluator","LLMPairwiseStringEvaluatorArgs","ExtractLLMCallOptions","CriteriaLike","PairwiseStringResultOutputParser","Promise","PairwiseStringEvalChain","Record","_langchain_core_prompt_values2","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/prompt_values\").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/prompt_values\").BasePromptValueInterface, any>;\n}\n//# sourceMappingURL=pairwise.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAWqBc,cAAAA,gCAAAA,SAAyCb,mBAAT,CAA6BO,cAA7B,CAAA,CAAA;EAA6BA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAGrDJ,YAAAA,EAAAA,MAAAA,EAAAA;EAAeD,WAAAA,CAAAA,WAAAA,EAAfC,UAAeD,EAAAA,GAAAA,cAAAA,EAAAA,EAAAA,UAAAA,EAA8BG,SAA9BH,GAAAA,SAAAA,CAAAA,EAAsDY,OAAtDZ,CAA8DK,cAA9DL,CAAAA;;;;;AAHqC;AAS5Da,cAAAA,uBAAAA,SAAgCN,0BAAAA,CAAT;EAO1BI,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAC4BD,aAAAA,CAAAA,EAAAA,MAAAA;EAAeI,cAAAA,CAAAA,EAAAA,MAAAA;EACnBZ,aAAAA,EAAAA,OAAAA;EAAkBa,iBAAAA,EAAAA,OAAAA;EAAGb,oBAAAA,EAAAA,MAAAA;EAOvCL,YAAAA,EATNc,gCASMd;EAAuCa,OAAAA,uBAAAA,CAAAA,QAAAA,CAAAA,EARjBA,YAQiBA,CAAAA,EARFI,MAQEJ,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAA0CJ,OAAAA,qBAAAA,CAAAA,MAAAA,CAAAA,EAP/DJ,kBAO+DI,CAAAA,EAP1CJ,kBAO0CI,CAAAA,GAAAA,EAP7CS,8BAAAA,CAAmEC,wBAAAA,EAOtBV,GAAAA,CAAAA;EAALW;;;;;;EAExBR,OAAAA,OAAAA,CAAAA,GAAAA,EAFpDZ,0BAEoDY,EAAAA,QAAAA,CAAAA,EAFbC,YAEaD,EAAAA,YAAAA,CAAAA,EAFgBS,OAEhBT,CAFwBQ,IAExBR,CAF6BH,iBAE7BG,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAF0DG,OAE1DH,CAFkEI,uBAElEJ,CAAAA;EAA6CN,cAAAA,CAAAA,MAAAA,EAD9FJ,WAC8FI,CAAAA,EAAAA,GAAAA;EAAYC,oBAAAA,CAAAA,IAAAA,EAAtGI,8BAAsGJ,EAAAA,WAAAA,EAAzDK,qBAAyDL,CAAAA,IAAAA,CAAAA,KAAAA,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAZD,SAAYC,GAAAA,kBAAAA,CAAAA,EAAqBQ,OAArBR,CAA6BL,WAA7BK,CAAAA;;;;AAlBtD;AAyB/E;;AAG4DW,cAHvCI,8BAAAA,SAAuCN,uBAAAA,CAGmEG;EAAhEd,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAHHW,iBAAAA,EAAAA,OAAAA;EAAuB,OAAA,qBAAA,CAAA,MAAA,CAAA,EAGzCX,kBAHyC,CAAA,EAGpBA,kBAHoB,CAAA,GAAA,EAGvBa,8BAAAA,CAAmEC,wBAAAA,EAH5C,GAAA,CAAA"}

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

@@ -1,4 +1,3 @@
-import { BasePromptValueInterface } from "../../langchain-core/dist/prompt_values.cjs";
 import { ConstitutionalPrinciple } from "../../chains/constitutional_ai/constitutional_principle.cjs";
 import { EvalOutputType, ExtractLLMCallOptions, LLMEvalChainInput, LLMStringEvaluator, StringEvaluatorArgs } from "../base.cjs";
 import { ChatGeneration, Generation } from "@langchain/core/outputs";
@@ -6,6 +5,7 @@ import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
 import { ChainValues } from "@langchain/core/utils/types";
 import { BasePromptTemplate } from "@langchain/core/prompts";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import * as _langchain_core_prompt_values1 from "@langchain/core/prompt_values";
 import { BaseCallbackConfig, Callbacks } from "@langchain/core/callbacks/manager";
 
 //#region src/evaluation/criteria/criteria.d.ts
@@ -35,7 +35,6 @@ declare class CriteriaEvalChain extends LLMStringEvaluator {
   requiresInput: boolean;
   requiresReference: boolean;
   skipReferenceWarning: string;
-  // The output parser to use for the evaluation chain.
   outputParser: BaseLLMOutputParser<EvalOutputType>;
   /**
    * Resolve the criteria to evaluate.
@@ -51,7 +50,7 @@ declare class CriteriaEvalChain extends LLMStringEvaluator {
    * Resolve the prompt to use for the evaluation.
    * @param prompt
    */
-  static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, BasePromptValueInterface, any>;
+  static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values1.BasePromptValueInterface, any>;
   /**
    * Create a new instance of the CriteriaEvalChain.
    * @param llm
@@ -76,9 +75,8 @@ declare class CriteriaEvalChain extends LLMStringEvaluator {
  */
 declare class LabeledCriteriaEvalChain extends CriteriaEvalChain {
   static lc_name(): string;
-  // Whether the evaluation requires a reference text.
   requiresReference: boolean;
-  static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, BasePromptValueInterface, any>;
+  static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values1.BasePromptValueInterface, any>;
 }
 //#endregion
 export { Criteria, CriteriaEvalChain, CriteriaEvalInput, CriteriaLike, CriteriaResultOutputParser, LabeledCriteriaEvalChain };

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_js1","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_prompt_values1","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    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/prompt_values\").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    requiresReference: boolean;\n    static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n}\n//# sourceMappingURL=criteria.d.ts.map"],"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;EAMHC,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;CAAuDR,GAJxEM,QAIwEN,GAJ7DK,uBAI6DL;;;;AAE8BA,cAFrFQ,0BAAAA,SAAmCf,mBAEkDO,CAF9BA,cAE8BA,CAAAA,CAAAA;EAARS,YAAAA,EAAAA,MAAAA,EAAAA;EAF1ChB,WAAAA,CAAAA,WAAAA,EAE3BG,UAF2BH,EAAAA,GAEZE,cAFYF,EAAAA,EAAAA,UAAAA,EAEkBK,SAFlBL,GAAAA,SAAAA,CAAAA,EAE0CgB,OAF1ChB,CAEkDO,cAFlDP,CAAAA;AAAmB;AAI1DiB,UAAAA,iBAAAA,CAAiB;EAKbC,KAAAA,CAAAA,EAAAA,MAAAA;EAOiBX,MAAAA,EAAAA,MAAAA;EAApBP,SAAAA,CAAAA,EAAAA,MAAAA;;AAUmCmB,cAjBhCD,iBAAAA,SAA0BT,kBAAAA,CAiBMU;EAKnBf,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAkBgB,aAAAA,CAAAA,EAAAA,MAAAA;EAAGhB,cAAAA,CAAAA,EAAAA,MAAAA;EAO/BL,aAAAA,EAAAA,OAAAA;EAAuCe,iBAAAA,EAAAA,OAAAA;EAA0CN,oBAAAA,EAAAA,MAAAA;EAALc,YAAAA,EAtBlFtB,mBAsBkFsB,CAtB9Df,cAsB8De,CAAAA;EAARC;;;;;;;;;EAOjEb,OAAAA,eAAAA,CAAAA,QAAAA,CAAAA,EAnBWI,YAmBXJ,CAAAA,EAnB0BS,MAmB1BT,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAsBC;;;;EAA8EK,OAAAA,aAAAA,CAAAA,MAAAA,CAAAA,EAd7FZ,kBAc6FY,CAAAA,EAdxEZ,kBAcwEY,CAAAA,GAAAA,EAd3EI,8BAAAA,CAAmEC,wBAAAA,EAcQL,GAAAA,CAAAA;EApChFP;AAAkB;AAyCjE;;;;EAAsDS,OAAAA,OAAAA,CAAAA,GAAAA,EAZ9BnB,0BAY8BmB,EAAAA,QAAAA,CAAAA,EAZSJ,YAYTI,EAAAA,YAAAA,CAAAA,EAZsCK,OAYtCL,CAZ8CI,IAY9CJ,CAZmDV,iBAYnDU,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAZgFF,OAYhFE,CAZwFA,iBAYxFA,CAAAA;EAAiB,YAAA,CAAA;IAAA,KAAA;IAAA,UAAA;IAAA;EAAA,CAAA,EAXpBR,mBAWoB,CAAA,EAXEO,iBAWF;;;;;yBAN5ChB;yBACAS,sBAAsBC,6CAA6CN,YAAYC,qBAAqBU,QAAQf;;;;;cAKlH0B,wBAAAA,SAAiCT,iBAAAA;;;gCAGpBd,qBAAqBA,wBAAHgB,8BAAAA,CAAmEC,wBAAAA"}