@langchain/classic 1.0.17 → 1.0.18

package/dist/document_transformers/openai_functions.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"openai_functions.cjs","names":["MappingDocumentTransformer","fields: { taggingChain: BaseChain }","document: Document","Document","schema: JsonSchema7ObjectType","options: TaggingChainOptions & { llm?: ChatOpenAI }","ChatOpenAI","createTaggingChain","schema: InteropZodObject"],"sources":["../../src/document_transformers/openai_functions.ts"],"sourcesContent":["import {\n  Document,\n  MappingDocumentTransformer,\n} from \"@langchain/core/documents\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nimport { InteropZodObject } from \"@langchain/core/utils/types\";\nimport {\n  type JsonSchema7ObjectType,\n  toJsonSchema,\n} from \"@langchain/core/utils/json_schema\";\nimport { BaseChain } from \"../chains/base.js\";\nimport {\n  TaggingChainOptions,\n  createTaggingChain,\n} from \"../chains/openai_functions/index.js\";\n\n/**\n * A transformer that tags metadata to a document using a tagging chain.\n */\nexport class MetadataTagger extends MappingDocumentTransformer {\n  static lc_name() {\n    return \"MetadataTagger\";\n  }\n\n  protected taggingChain: BaseChain;\n\n  constructor(fields: { taggingChain: BaseChain }) {\n    super();\n    this.taggingChain = fields.taggingChain;\n    if (this.taggingChain.inputKeys.length !== 1) {\n      throw new Error(\n        \"Invalid input chain. The input chain must have exactly one input.\"\n      );\n    }\n    if (this.taggingChain.outputKeys.length !== 1) {\n      throw new Error(\n        \"Invalid input chain. The input chain must have exactly one output.\"\n      );\n    }\n  }\n\n  async _transformDocument(document: Document): Promise<Document> {\n    const taggingChainResponse = await this.taggingChain.call({\n      [this.taggingChain.inputKeys[0]]: document.pageContent,\n    });\n    const extractedMetadata =\n      taggingChainResponse[this.taggingChain.outputKeys[0]];\n    return new Document({\n      pageContent: document.pageContent,\n      metadata: { ...extractedMetadata, ...document.metadata },\n    });\n  }\n}\n\nexport function createMetadataTagger(\n  schema: JsonSchema7ObjectType,\n  options: TaggingChainOptions & { llm?: ChatOpenAI }\n) {\n  const { llm = new ChatOpenAI({ model: \"gpt-3.5-turbo-0613\" }), ...rest } =\n    options;\n  const taggingChain = createTaggingChain(schema, llm, rest);\n  return new MetadataTagger({ taggingChain });\n}\n\nexport function createMetadataTaggerFromZod(\n  schema: InteropZodObject,\n  options: TaggingChainOptions & { llm?: ChatOpenAI }\n) {\n  return createMetadataTagger(\n    toJsonSchema(schema) as JsonSchema7ObjectType,\n    options\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAmBA,IAAa,iBAAb,cAAoCA,sDAA2B;CAC7D,OAAO,UAAU;AACf,SAAO;CACR;CAED,AAAU;CAEV,YAAYC,QAAqC;EAC/C,OAAO;EACP,KAAK,eAAe,OAAO;AAC3B,MAAI,KAAK,aAAa,UAAU,WAAW,EACzC,OAAM,IAAI,MACR;AAGJ,MAAI,KAAK,aAAa,WAAW,WAAW,EAC1C,OAAM,IAAI,MACR;CAGL;CAED,MAAM,mBAAmBC,UAAuC;EAC9D,MAAM,uBAAuB,MAAM,KAAK,aAAa,KAAK,GACvD,KAAK,aAAa,UAAU,KAAK,SAAS,YAC5C,EAAC;EACF,MAAM,oBACJ,qBAAqB,KAAK,aAAa,WAAW;AACpD,SAAO,IAAIC,oCAAS;GAClB,aAAa,SAAS;GACtB,UAAU;IAAE,GAAG;IAAmB,GAAG,SAAS;GAAU;EACzD;CACF;AACF;AAED,SAAgB,qBACdC,QACAC,SACA;CACA,MAAM,EAAE,MAAM,IAAIC,8BAAW,EAAE,OAAO,qBAAsB,GAAG,GAAG,MAAM,GACtE;CACF,MAAM,eAAeC,mCAAmB,QAAQ,KAAK,KAAK;AAC1D,QAAO,IAAI,eAAe,EAAE,aAAc;AAC3C;AAED,SAAgB,4BACdC,QACAH,SACA;AACA,QAAO,0EACQ,OAAO,EACpB,QACD;AACF"}
+{"version":3,"file":"openai_functions.cjs","names":["MappingDocumentTransformer","Document","ChatOpenAI","createTaggingChain"],"sources":["../../src/document_transformers/openai_functions.ts"],"sourcesContent":["import {\n  Document,\n  MappingDocumentTransformer,\n} from \"@langchain/core/documents\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nimport { InteropZodObject } from \"@langchain/core/utils/types\";\nimport {\n  type JsonSchema7ObjectType,\n  toJsonSchema,\n} from \"@langchain/core/utils/json_schema\";\nimport { BaseChain } from \"../chains/base.js\";\nimport {\n  TaggingChainOptions,\n  createTaggingChain,\n} from \"../chains/openai_functions/index.js\";\n\n/**\n * A transformer that tags metadata to a document using a tagging chain.\n */\nexport class MetadataTagger extends MappingDocumentTransformer {\n  static lc_name() {\n    return \"MetadataTagger\";\n  }\n\n  protected taggingChain: BaseChain;\n\n  constructor(fields: { taggingChain: BaseChain }) {\n    super();\n    this.taggingChain = fields.taggingChain;\n    if (this.taggingChain.inputKeys.length !== 1) {\n      throw new Error(\n        \"Invalid input chain. The input chain must have exactly one input.\"\n      );\n    }\n    if (this.taggingChain.outputKeys.length !== 1) {\n      throw new Error(\n        \"Invalid input chain. The input chain must have exactly one output.\"\n      );\n    }\n  }\n\n  async _transformDocument(document: Document): Promise<Document> {\n    const taggingChainResponse = await this.taggingChain.call({\n      [this.taggingChain.inputKeys[0]]: document.pageContent,\n    });\n    const extractedMetadata =\n      taggingChainResponse[this.taggingChain.outputKeys[0]];\n    return new Document({\n      pageContent: document.pageContent,\n      metadata: { ...extractedMetadata, ...document.metadata },\n    });\n  }\n}\n\nexport function createMetadataTagger(\n  schema: JsonSchema7ObjectType,\n  options: TaggingChainOptions & { llm?: ChatOpenAI }\n) {\n  const { llm = new ChatOpenAI({ model: \"gpt-3.5-turbo-0613\" }), ...rest } =\n    options;\n  const taggingChain = createTaggingChain(schema, llm, rest);\n  return new MetadataTagger({ taggingChain });\n}\n\nexport function createMetadataTaggerFromZod(\n  schema: InteropZodObject,\n  options: TaggingChainOptions & { llm?: ChatOpenAI }\n) {\n  return createMetadataTagger(\n    toJsonSchema(schema) as JsonSchema7ObjectType,\n    options\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAmBA,IAAa,iBAAb,cAAoCA,qDAA2B;CAC7D,OAAO,UAAU;AACf,SAAO;;CAGT,AAAU;CAEV,YAAY,QAAqC;AAC/C,SAAO;AACP,OAAK,eAAe,OAAO;AAC3B,MAAI,KAAK,aAAa,UAAU,WAAW,EACzC,OAAM,IAAI,MACR,oEACD;AAEH,MAAI,KAAK,aAAa,WAAW,WAAW,EAC1C,OAAM,IAAI,MACR,qEACD;;CAIL,MAAM,mBAAmB,UAAuC;EAI9D,MAAM,qBAHuB,MAAM,KAAK,aAAa,KAAK,GACvD,KAAK,aAAa,UAAU,KAAK,SAAS,aAC5C,CAAC,EAEqB,KAAK,aAAa,WAAW;AACpD,SAAO,IAAIC,mCAAS;GAClB,aAAa,SAAS;GACtB,UAAU;IAAE,GAAG;IAAmB,GAAG,SAAS;IAAU;GACzD,CAAC;;;AAIN,SAAgB,qBACd,QACA,SACA;CACA,MAAM,EAAE,MAAM,IAAIC,6BAAW,EAAE,OAAO,sBAAsB,CAAC,EAAE,GAAG,SAChE;AAEF,QAAO,IAAI,eAAe,EAAE,cADPC,mCAAmB,QAAQ,KAAK,KAAK,EAChB,CAAC;;AAG7C,SAAgB,4BACd,QACA,SACA;AACA,QAAO,yEACQ,OAAO,EACpB,QACD"}

package/dist/document_transformers/openai_functions.d.cts

@@ -6,7 +6,6 @@ import { Document, MappingDocumentTransformer } from "@langchain/core/documents"
 import { JsonSchema7ObjectType } from "@langchain/core/utils/json_schema";
 
 //#region src/document_transformers/openai_functions.d.ts
-
 /**
  * A transformer that tags metadata to a document using a tagging chain.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"openai_functions.d.cts","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":";;;;;;;;;;;AASA;AAE4BK,cAFPE,cAAAA,SAAuBN,0BAAAA,CAEhBI;EAENA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAEWL,UAAAA,YAAAA,EAJLK,SAIKL;EAAmBA,WAAAA,CAAAA,MAAAA,EAAAA;IAARQ,YAAAA,EAFtBH,SAEsBG;EANAP,CAAAA;EAA0B,kBAAA,CAAA,QAAA,EAMrCD,QANqC,CAAA,EAM1BQ,OAN0B,CAMlBR,QANkB,CAAA;AAQtE;AAAqDI,iBAA7BK,oBAAAA,CAA6BL,MAAAA,EAAAA,qBAAAA,EAAAA,OAAAA,EAAgCE,mBAAhCF,GAAAA;EAAgCE,GAAAA,CAAAA,EAC3EJ,UAD2EI;CAC3EJ,CAAAA,EACNK,cADML;AACNK,iBACoBG,2BAAAA,CADpBH,MAAAA,EACwDJ,gBADxDI,EAAAA,OAAAA,EACmFD,mBADnFC,GAAAA;EAAc,GAAA,CAAA,EAERL,UAFQ;AAClB,CAAA,CAAA,EAEIK,cAFoBG"}
+{"version":3,"file":"openai_functions.d.cts","names":[],"sources":["../../src/document_transformers/openai_functions.ts"],"mappings":";;;;;;;;;;AAmBA;cAAa,cAAA,SAAuB,0BAAA;EAAA,OAC3B,OAAA,CAAA;EAAA,UAIG,YAAA,EAAc,SAAA;EAExB,WAAA,CAAY,MAAA;IAAU,YAAA,EAAc,SAAA;EAAA;EAe9B,kBAAA,CAAmB,QAAA,EAAU,QAAA,GAAW,OAAA,CAAQ,QAAA;AAAA;AAAA,iBAaxC,oBAAA,CACd,MAAA,EAAQ,qBAAA,EACR,OAAA,EAAS,mBAAA;EAAwB,GAAA,GAAM,UAAA;AAAA,IAAY,cAAA;AAAA,iBAQrC,2BAAA,CACd,MAAA,EAAQ,gBAAA,EACR,OAAA,EAAS,mBAAA;EAAwB,GAAA,GAAM,UAAA;AAAA,IAAY,cAAA"}

package/dist/document_transformers/openai_functions.d.ts

@@ -1,10 +1,10 @@
 import { BaseChain } from "../chains/base.js";
 import { TaggingChainOptions } from "../chains/openai_functions/tagging.js";
 import "../chains/openai_functions/index.js";
-import { Document, MappingDocumentTransformer } from "@langchain/core/documents";
 import { InteropZodObject } from "@langchain/core/utils/types";
 import { JsonSchema7ObjectType } from "@langchain/core/utils/json_schema";
 import { ChatOpenAI } from "@langchain/openai";
+import { Document, MappingDocumentTransformer } from "@langchain/core/documents";
 
 //#region src/document_transformers/openai_functions.d.ts
 /**

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//# 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"}
+{"version":3,"file":"openai_functions.d.ts","names":[],"sources":["../../src/document_transformers/openai_functions.ts"],"mappings":";;;;;;;;;;;;cAmBa,cAAA,SAAuB,0BAAA;EAAA,OAC3B,OAAA,CAAA;EAAA,UAIG,YAAA,EAAc,SAAA;EAExB,WAAA,CAAY,MAAA;IAAU,YAAA,EAAc,SAAA;EAAA;EAe9B,kBAAA,CAAmB,QAAA,EAAU,QAAA,GAAW,OAAA,CAAQ,QAAA;AAAA;AAAA,iBAaxC,oBAAA,CACd,MAAA,EAAQ,qBAAA,EACR,OAAA,EAAS,mBAAA;EAAwB,GAAA,GAAM,UAAA;AAAA,IAAY,cAAA;AAAA,iBAQrC,2BAAA,CACd,MAAA,EAAQ,gBAAA,EACR,OAAA,EAAS,mBAAA;EAAwB,GAAA,GAAM,UAAA;AAAA,IAAY,cAAA"}

package/dist/document_transformers/openai_functions.js

@@ -1,13 +1,12 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import { createTaggingChain } from "../chains/openai_functions/tagging.js";
 import "../chains/openai_functions/index.js";
-import { Document, MappingDocumentTransformer } from "@langchain/core/documents";
 import { toJsonSchema } from "@langchain/core/utils/json_schema";
 import { ChatOpenAI } from "@langchain/openai";
+import { Document, MappingDocumentTransformer } from "@langchain/core/documents";
 
 //#region src/document_transformers/openai_functions.ts
-var openai_functions_exports = {};
-__export(openai_functions_exports, {
+var openai_functions_exports = /* @__PURE__ */ __exportAll({
 	MetadataTagger: () => MetadataTagger,
 	createMetadataTagger: () => createMetadataTagger,
 	createMetadataTaggerFromZod: () => createMetadataTaggerFromZod
@@ -27,8 +26,7 @@ var MetadataTagger = class extends MappingDocumentTransformer {
 		if (this.taggingChain.outputKeys.length !== 1) throw new Error("Invalid input chain. The input chain must have exactly one output.");
 	}
 	async _transformDocument(document) {
-		const taggingChainResponse = await this.taggingChain.call({ [this.taggingChain.inputKeys[0]]: document.pageContent });
-		const extractedMetadata = taggingChainResponse[this.taggingChain.outputKeys[0]];
+		const extractedMetadata = (await this.taggingChain.call({ [this.taggingChain.inputKeys[0]]: document.pageContent }))[this.taggingChain.outputKeys[0]];
 		return new Document({
 			pageContent: document.pageContent,
 			metadata: {
@@ -39,9 +37,8 @@ var MetadataTagger = class extends MappingDocumentTransformer {
 	}
 };
 function createMetadataTagger(schema, options) {
-	const { llm = new ChatOpenAI({ model: "gpt-3.5-turbo-0613" }),...rest } = options;
-	const taggingChain = createTaggingChain(schema, llm, rest);
-	return new MetadataTagger({ taggingChain });
+	const { llm = new ChatOpenAI({ model: "gpt-3.5-turbo-0613" }), ...rest } = options;
+	return new MetadataTagger({ taggingChain: createTaggingChain(schema, llm, rest) });
 }
 function createMetadataTaggerFromZod(schema, options) {
 	return createMetadataTagger(toJsonSchema(schema), options);

package/dist/document_transformers/openai_functions.js.map

@@ -1 +1 @@
-{"version":3,"file":"openai_functions.js","names":["fields: { taggingChain: BaseChain }","document: Document","schema: JsonSchema7ObjectType","options: TaggingChainOptions & { llm?: ChatOpenAI }","schema: InteropZodObject"],"sources":["../../src/document_transformers/openai_functions.ts"],"sourcesContent":["import {\n  Document,\n  MappingDocumentTransformer,\n} from \"@langchain/core/documents\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nimport { InteropZodObject } from \"@langchain/core/utils/types\";\nimport {\n  type JsonSchema7ObjectType,\n  toJsonSchema,\n} from \"@langchain/core/utils/json_schema\";\nimport { BaseChain } from \"../chains/base.js\";\nimport {\n  TaggingChainOptions,\n  createTaggingChain,\n} from \"../chains/openai_functions/index.js\";\n\n/**\n * A transformer that tags metadata to a document using a tagging chain.\n */\nexport class MetadataTagger extends MappingDocumentTransformer {\n  static lc_name() {\n    return \"MetadataTagger\";\n  }\n\n  protected taggingChain: BaseChain;\n\n  constructor(fields: { taggingChain: BaseChain }) {\n    super();\n    this.taggingChain = fields.taggingChain;\n    if (this.taggingChain.inputKeys.length !== 1) {\n      throw new Error(\n        \"Invalid input chain. The input chain must have exactly one input.\"\n      );\n    }\n    if (this.taggingChain.outputKeys.length !== 1) {\n      throw new Error(\n        \"Invalid input chain. The input chain must have exactly one output.\"\n      );\n    }\n  }\n\n  async _transformDocument(document: Document): Promise<Document> {\n    const taggingChainResponse = await this.taggingChain.call({\n      [this.taggingChain.inputKeys[0]]: document.pageContent,\n    });\n    const extractedMetadata =\n      taggingChainResponse[this.taggingChain.outputKeys[0]];\n    return new Document({\n      pageContent: document.pageContent,\n      metadata: { ...extractedMetadata, ...document.metadata },\n    });\n  }\n}\n\nexport function createMetadataTagger(\n  schema: JsonSchema7ObjectType,\n  options: TaggingChainOptions & { llm?: ChatOpenAI }\n) {\n  const { llm = new ChatOpenAI({ model: \"gpt-3.5-turbo-0613\" }), ...rest } =\n    options;\n  const taggingChain = createTaggingChain(schema, llm, rest);\n  return new MetadataTagger({ taggingChain });\n}\n\nexport function createMetadataTaggerFromZod(\n  schema: InteropZodObject,\n  options: TaggingChainOptions & { llm?: ChatOpenAI }\n) {\n  return createMetadataTagger(\n    toJsonSchema(schema) as JsonSchema7ObjectType,\n    options\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAmBA,IAAa,iBAAb,cAAoC,2BAA2B;CAC7D,OAAO,UAAU;AACf,SAAO;CACR;CAED,AAAU;CAEV,YAAYA,QAAqC;EAC/C,OAAO;EACP,KAAK,eAAe,OAAO;AAC3B,MAAI,KAAK,aAAa,UAAU,WAAW,EACzC,OAAM,IAAI,MACR;AAGJ,MAAI,KAAK,aAAa,WAAW,WAAW,EAC1C,OAAM,IAAI,MACR;CAGL;CAED,MAAM,mBAAmBC,UAAuC;EAC9D,MAAM,uBAAuB,MAAM,KAAK,aAAa,KAAK,GACvD,KAAK,aAAa,UAAU,KAAK,SAAS,YAC5C,EAAC;EACF,MAAM,oBACJ,qBAAqB,KAAK,aAAa,WAAW;AACpD,SAAO,IAAI,SAAS;GAClB,aAAa,SAAS;GACtB,UAAU;IAAE,GAAG;IAAmB,GAAG,SAAS;GAAU;EACzD;CACF;AACF;AAED,SAAgB,qBACdC,QACAC,SACA;CACA,MAAM,EAAE,MAAM,IAAI,WAAW,EAAE,OAAO,qBAAsB,GAAG,GAAG,MAAM,GACtE;CACF,MAAM,eAAe,mBAAmB,QAAQ,KAAK,KAAK;AAC1D,QAAO,IAAI,eAAe,EAAE,aAAc;AAC3C;AAED,SAAgB,4BACdC,QACAD,SACA;AACA,QAAO,qBACL,aAAa,OAAO,EACpB,QACD;AACF"}
+{"version":3,"file":"openai_functions.js","names":[],"sources":["../../src/document_transformers/openai_functions.ts"],"sourcesContent":["import {\n  Document,\n  MappingDocumentTransformer,\n} from \"@langchain/core/documents\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nimport { InteropZodObject } from \"@langchain/core/utils/types\";\nimport {\n  type JsonSchema7ObjectType,\n  toJsonSchema,\n} from \"@langchain/core/utils/json_schema\";\nimport { BaseChain } from \"../chains/base.js\";\nimport {\n  TaggingChainOptions,\n  createTaggingChain,\n} from \"../chains/openai_functions/index.js\";\n\n/**\n * A transformer that tags metadata to a document using a tagging chain.\n */\nexport class MetadataTagger extends MappingDocumentTransformer {\n  static lc_name() {\n    return \"MetadataTagger\";\n  }\n\n  protected taggingChain: BaseChain;\n\n  constructor(fields: { taggingChain: BaseChain }) {\n    super();\n    this.taggingChain = fields.taggingChain;\n    if (this.taggingChain.inputKeys.length !== 1) {\n      throw new Error(\n        \"Invalid input chain. The input chain must have exactly one input.\"\n      );\n    }\n    if (this.taggingChain.outputKeys.length !== 1) {\n      throw new Error(\n        \"Invalid input chain. The input chain must have exactly one output.\"\n      );\n    }\n  }\n\n  async _transformDocument(document: Document): Promise<Document> {\n    const taggingChainResponse = await this.taggingChain.call({\n      [this.taggingChain.inputKeys[0]]: document.pageContent,\n    });\n    const extractedMetadata =\n      taggingChainResponse[this.taggingChain.outputKeys[0]];\n    return new Document({\n      pageContent: document.pageContent,\n      metadata: { ...extractedMetadata, ...document.metadata },\n    });\n  }\n}\n\nexport function createMetadataTagger(\n  schema: JsonSchema7ObjectType,\n  options: TaggingChainOptions & { llm?: ChatOpenAI }\n) {\n  const { llm = new ChatOpenAI({ model: \"gpt-3.5-turbo-0613\" }), ...rest } =\n    options;\n  const taggingChain = createTaggingChain(schema, llm, rest);\n  return new MetadataTagger({ taggingChain });\n}\n\nexport function createMetadataTaggerFromZod(\n  schema: InteropZodObject,\n  options: TaggingChainOptions & { llm?: ChatOpenAI }\n) {\n  return createMetadataTagger(\n    toJsonSchema(schema) as JsonSchema7ObjectType,\n    options\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAmBA,IAAa,iBAAb,cAAoC,2BAA2B;CAC7D,OAAO,UAAU;AACf,SAAO;;CAGT,AAAU;CAEV,YAAY,QAAqC;AAC/C,SAAO;AACP,OAAK,eAAe,OAAO;AAC3B,MAAI,KAAK,aAAa,UAAU,WAAW,EACzC,OAAM,IAAI,MACR,oEACD;AAEH,MAAI,KAAK,aAAa,WAAW,WAAW,EAC1C,OAAM,IAAI,MACR,qEACD;;CAIL,MAAM,mBAAmB,UAAuC;EAI9D,MAAM,qBAHuB,MAAM,KAAK,aAAa,KAAK,GACvD,KAAK,aAAa,UAAU,KAAK,SAAS,aAC5C,CAAC,EAEqB,KAAK,aAAa,WAAW;AACpD,SAAO,IAAI,SAAS;GAClB,aAAa,SAAS;GACtB,UAAU;IAAE,GAAG;IAAmB,GAAG,SAAS;IAAU;GACzD,CAAC;;;AAIN,SAAgB,qBACd,QACA,SACA;CACA,MAAM,EAAE,MAAM,IAAI,WAAW,EAAE,OAAO,sBAAsB,CAAC,EAAE,GAAG,SAChE;AAEF,QAAO,IAAI,eAAe,EAAE,cADP,mBAAmB,QAAQ,KAAK,KAAK,EAChB,CAAC;;AAG7C,SAAgB,4BACd,QACA,SACA;AACA,QAAO,qBACL,aAAa,OAAO,EACpB,QACD"}

package/dist/embeddings/cache_backed.cjs

@@ -1,11 +1,11 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 const require_storage_encoder_backed = require('../storage/encoder_backed.cjs');
-const __langchain_core_utils_hash = require_rolldown_runtime.__toESM(require("@langchain/core/utils/hash"));
-const __langchain_core_embeddings = require_rolldown_runtime.__toESM(require("@langchain/core/embeddings"));
+let _langchain_core_utils_hash = require("@langchain/core/utils/hash");
+let _langchain_core_embeddings = require("@langchain/core/embeddings");
 
 //#region src/embeddings/cache_backed.ts
-var cache_backed_exports = {};
-require_rolldown_runtime.__export(cache_backed_exports, { CacheBackedEmbeddings: () => CacheBackedEmbeddings });
+var cache_backed_exports = /* @__PURE__ */ require_runtime.__exportAll({ CacheBackedEmbeddings: () => CacheBackedEmbeddings });
 /**
 * Interface for caching results from embedding models.
 *
@@ -53,7 +53,7 @@ require_rolldown_runtime.__export(cache_backed_exports, { CacheBackedEmbeddings:
 *
 * ```
 */
-var CacheBackedEmbeddings = class extends __langchain_core_embeddings.Embeddings {
+var CacheBackedEmbeddings = class extends _langchain_core_embeddings.Embeddings {
 	underlyingEmbeddings;
 	documentEmbeddingStore;
 	constructor(fields) {
@@ -118,7 +118,7 @@ var CacheBackedEmbeddings = class extends __langchain_core_embeddings.Embeddings
 		const decoder = new TextDecoder();
 		const encoderBackedStore = new require_storage_encoder_backed.EncoderBackedStore({
 			store: documentEmbeddingStore,
-			keyEncoder: (key) => (options?.namespace ?? "") + (0, __langchain_core_utils_hash.sha256)(key),
+			keyEncoder: (key) => (options?.namespace ?? "") + (0, _langchain_core_utils_hash.sha256)(key),
 			valueSerializer: (value) => encoder.encode(JSON.stringify(value)),
 			valueDeserializer: (serializedValue) => JSON.parse(decoder.decode(serializedValue))
 		});

package/dist/embeddings/cache_backed.cjs.map

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

package/dist/embeddings/cache_backed.d.cts

@@ -3,7 +3,6 @@ import { Embeddings, EmbeddingsInterface } from "@langchain/core/embeddings";
 import { BaseStore } from "@langchain/core/stores";
 
 //#region src/embeddings/cache_backed.d.ts
-
 /**
  * Interface for the fields required to initialize an instance of the
  * CacheBackedEmbeddings class.

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//# 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"}
+{"version":3,"file":"cache_backed.d.cts","names":[],"sources":["../../src/embeddings/cache_backed.ts"],"mappings":";;;;;;;AAcA;;UAAiB,2BAAA,SAAoC,iBAAA;EACnD,oBAAA,EAAsB,mBAAA;EACtB,sBAAA,EAAwB,SAAA;AAAA;;;;;;;;;;AAkD1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,qBAAA,SAA8B,UAAA;EAAA,UAC/B,oBAAA,EAAsB,mBAAA;EAAA,UAEtB,sBAAA,EAAwB,SAAA;EAElC,WAAA,CAAY,MAAA,EAAQ,2BAAA;;;;;;;;;;;;;;;;EAqBd,UAAA,CAAW,QAAA,WAAmB,OAAA;;;;;;;;;;;EAc9B,cAAA,CAAe,SAAA,aAAsB,OAAA;;;;;;;;;SAgCpC,cAAA,CACL,oBAAA,EAAsB,mBAAA,EACtB,sBAAA,EAAwB,SAAA,SAAkB,UAAA,GAC1C,OAAA;IACE,SAAA;EAAA,IACD,qBAAA;AAAA"}

package/dist/embeddings/cache_backed.d.ts

@@ -3,7 +3,6 @@ import { Embeddings, EmbeddingsInterface } from "@langchain/core/embeddings";
 import { BaseStore } from "@langchain/core/stores";
 
 //#region src/embeddings/cache_backed.d.ts
-
 /**
  * Interface for the fields required to initialize an instance of the
  * CacheBackedEmbeddings class.

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//# 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"}
+{"version":3,"file":"cache_backed.d.ts","names":[],"sources":["../../src/embeddings/cache_backed.ts"],"mappings":";;;;;;;AAcA;;UAAiB,2BAAA,SAAoC,iBAAA;EACnD,oBAAA,EAAsB,mBAAA;EACtB,sBAAA,EAAwB,SAAA;AAAA;;;;;;;;;;AAkD1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,qBAAA,SAA8B,UAAA;EAAA,UAC/B,oBAAA,EAAsB,mBAAA;EAAA,UAEtB,sBAAA,EAAwB,SAAA;EAElC,WAAA,CAAY,MAAA,EAAQ,2BAAA;;;;;;;;;;;;;;;;EAqBd,UAAA,CAAW,QAAA,WAAmB,OAAA;;;;;;;;;;;EAc9B,cAAA,CAAe,SAAA,aAAsB,OAAA;;;;;;;;;SAgCpC,cAAA,CACL,oBAAA,EAAsB,mBAAA,EACtB,sBAAA,EAAwB,SAAA,SAAkB,UAAA,GAC1C,OAAA;IACE,SAAA;EAAA,IACD,qBAAA;AAAA"}

package/dist/embeddings/cache_backed.js

@@ -1,11 +1,10 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import { EncoderBackedStore } from "../storage/encoder_backed.js";
 import { sha256 } from "@langchain/core/utils/hash";
 import { Embeddings } from "@langchain/core/embeddings";
 
 //#region src/embeddings/cache_backed.ts
-var cache_backed_exports = {};
-__export(cache_backed_exports, { CacheBackedEmbeddings: () => CacheBackedEmbeddings });
+var cache_backed_exports = /* @__PURE__ */ __exportAll({ CacheBackedEmbeddings: () => CacheBackedEmbeddings });
 /**
 * Interface for caching results from embedding models.
 *

package/dist/embeddings/cache_backed.js.map

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

package/dist/embeddings/fake.cjs

@@ -1,8 +1,9 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 
 //#region src/embeddings/fake.ts
-var fake_exports = {};
-require_rolldown_runtime.__reExport(fake_exports, require("@langchain/core/utils/testing"));
+var fake_exports = /* @__PURE__ */ require_runtime.__exportAll({});
+require_runtime.__reExport(fake_exports, require("@langchain/core/utils/testing"));
 
 //#endregion
 Object.defineProperty(exports, 'fake_exports', {
@@ -11,11 +12,11 @@ Object.defineProperty(exports, 'fake_exports', {
     return fake_exports;
   }
 });
-var __langchain_core_utils_testing = require("@langchain/core/utils/testing");
-Object.keys(__langchain_core_utils_testing).forEach(function (k) {
+var _langchain_core_utils_testing = require("@langchain/core/utils/testing");
+Object.keys(_langchain_core_utils_testing).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,
-    get: function () { return __langchain_core_utils_testing[k]; }
+    get: function () { return _langchain_core_utils_testing[k]; }
   });
 });
 

package/dist/embeddings/fake.js

@@ -1,11 +1,11 @@
-import { __reExport } from "../_virtual/rolldown_runtime.js";
+import { __exportAll, __reExport } from "../_virtual/_rolldown/runtime.js";
 
 export * from "@langchain/core/utils/testing"
 
 //#region src/embeddings/fake.ts
-var fake_exports = {};
-import * as import___langchain_core_utils_testing from "@langchain/core/utils/testing";
-__reExport(fake_exports, import___langchain_core_utils_testing);
+var fake_exports = /* @__PURE__ */ __exportAll({});
+import * as import__langchain_core_utils_testing from "@langchain/core/utils/testing";
+__reExport(fake_exports, import__langchain_core_utils_testing);
 
 //#endregion
 export { fake_exports };

package/dist/evaluation/agents/index.js

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

package/dist/evaluation/agents/prompt.cjs

@@ -1,7 +1,10 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
-const __langchain_core_prompts = require_rolldown_runtime.__toESM(require("@langchain/core/prompts"));
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
+let _langchain_core_prompts = require("@langchain/core/prompts");
 
 //#region src/evaluation/agents/prompt.ts
+/**
+* Prompt for trajectory evaluation chain.
+*/
 const EVAL_TEMPLATE = `An AI language model has been given access to the following set of tools to help answer a user's question.
 
 The tools given to the AI model are:
@@ -87,11 +90,11 @@ The model did not use the appropriate tools to answer the question.\
 Judgment: Given the good reasoning in the final answer but otherwise poor performance, we give the model a score of 2.
 
 Score: 2`;
-const EVAL_CHAT_PROMPT = /* @__PURE__ */ __langchain_core_prompts.ChatPromptTemplate.fromMessages([
-	/* @__PURE__ */ __langchain_core_prompts.SystemMessagePromptTemplate.fromTemplate("You are a helpful assistant that evaluates language models."),
-	/* @__PURE__ */ __langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),
-	/* @__PURE__ */ __langchain_core_prompts.AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),
-	/* @__PURE__ */ __langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate(EVAL_TEMPLATE)
+const EVAL_CHAT_PROMPT = /* @__PURE__ */ _langchain_core_prompts.ChatPromptTemplate.fromMessages([
+	/* @__PURE__ */ _langchain_core_prompts.SystemMessagePromptTemplate.fromTemplate("You are a helpful assistant that evaluates language models."),
+	/* @__PURE__ */ _langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),
+	/* @__PURE__ */ _langchain_core_prompts.AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),
+	/* @__PURE__ */ _langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate(EVAL_TEMPLATE)
 ]);
 const TOOL_FREE_EVAL_TEMPLATE = `An AI language model has been given access to a set of tools to help answer a user's question.
 
@@ -119,11 +122,11 @@ i. Is the final answer helpful?
     iii. Does the AI language model use the tools in a helpful way?
     iv. Does the AI language model use too many steps to answer the question?
     v. Are the appropriate tools used to answer the question?`;
-const TOOL_FREE_EVAL_CHAT_PROMPT = /* @__PURE__ */ __langchain_core_prompts.ChatPromptTemplate.fromMessages([
-	/* @__PURE__ */ __langchain_core_prompts.SystemMessagePromptTemplate.fromTemplate("You are a helpful assistant that evaluates language models."),
-	/* @__PURE__ */ __langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),
-	/* @__PURE__ */ __langchain_core_prompts.AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),
-	/* @__PURE__ */ __langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate(TOOL_FREE_EVAL_TEMPLATE)
+const TOOL_FREE_EVAL_CHAT_PROMPT = /* @__PURE__ */ _langchain_core_prompts.ChatPromptTemplate.fromMessages([
+	/* @__PURE__ */ _langchain_core_prompts.SystemMessagePromptTemplate.fromTemplate("You are a helpful assistant that evaluates language models."),
+	/* @__PURE__ */ _langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),
+	/* @__PURE__ */ _langchain_core_prompts.AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),
+	/* @__PURE__ */ _langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate(TOOL_FREE_EVAL_TEMPLATE)
 ]);
 
 //#endregion

package/dist/evaluation/agents/prompt.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"prompt.cjs","names":["ChatPromptTemplate","SystemMessagePromptTemplate","HumanMessagePromptTemplate","AIMessagePromptTemplate"],"sources":["../../../src/evaluation/agents/prompt.ts"],"sourcesContent":["/**\n * Prompt for trajectory evaluation chain.\n */\n\nimport {\n  AIMessagePromptTemplate,\n  ChatPromptTemplate,\n  HumanMessagePromptTemplate,\n  SystemMessagePromptTemplate,\n} from \"@langchain/core/prompts\";\n\nconst EVAL_TEMPLATE = `An AI language model has been given access to the following set of tools to help answer a user's question.\n\nThe tools given to the AI model are:\n[TOOL_DESCRIPTIONS]\n{toolDescriptions}\n[END_TOOL_DESCRIPTIONS]\n\nThe question the human asked the AI model was:\n[QUESTION]\n{question}\n[END_QUESTION]{reference}\n\nThe AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\n{agentTrajectory}\n[END_AGENT_TRAJECTORY]\n\nThe AI language model's final answer to the question was:\n[RESPONSE]\n{answer}\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\nii. Does the AI language use a logical sequence of tools to answer the question?\niii. Does the AI language model use the tools in a helpful way?\niv. Does the AI language model use too many steps to answer the question?\nv. Are the appropriate tools used to answer the question?`;\n\nconst EXAMPLE_INPUT = `An AI language model has been given access to the following set of tools to help answer a user's question.\n\nThe tools given to the AI model are:\n[TOOL_DESCRIPTIONS]\nTool 1:\nName: Search\nDescription: useful for when you need to ask with search\n\nTool 2:\nName: Lookup\nDescription: useful for when you need to ask with lookup\n\nTool 3:\nName: Calculator\nDescription: useful for doing calculations\n\nTool 4:\nName: Search the Web (SerpAPI)\nDescription: useful for when you need to answer questions about current events\n[END_TOOL_DESCRIPTIONS]\n\nThe question the human asked the AI model was: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?\n\n    The AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\nStep 1:\nTool used: Search the Web (SerpAPI)\nTool input: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?\nTool output: The Statue of Liberty was given to the United States by France, as a symbol of the two countries' friendship. It was erected atop an American-designed ...\n[END_AGENT_TRAJECTORY]\n\n[RESPONSE]\nThe AI language model's final answer to the question was: There are different ways to measure the length of the United States, but if we use the distance between the Statue of Liberty and the westernmost point of the contiguous United States (Cape Alava, Washington), which is approximately 2,857 miles (4,596 km), and assume that the Statue of Liberty is 305 feet (93 meters) tall, then the statue would stretch across the United States approximately 17.5 times if laid end to end.\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\nii. Does the AI language use a logical sequence of tools to answer the question?\niii. Does the AI language model use the tools in a helpful way?\niv. Does the AI language model use too many steps to answer the question?\nv. Are the appropriate tools used to answer the question?`;\n\nconst EXAMPLE_OUTPUT = `First, let's evaluate the final answer. The final uses good reasoning but is wrong. 2,857 divided by 305 is not 17.5.\\\nThe model should have used the calculator to figure this out. Second does the model use a logical sequence of tools to answer the question?\\\nThe way model uses the search is not helpful. The model should have used the search tool to figure the width of the US or the height of the statue.\\\nThe model didn't use the calculator tool and gave an incorrect answer. The search API should be used for current events or specific questions.\\\nThe tools were not used in a helpful way. The model did not use too many steps to answer the question.\\\nThe model did not use the appropriate tools to answer the question.\\\n\nJudgment: Given the good reasoning in the final answer but otherwise poor performance, we give the model a score of 2.\n\nScore: 2`;\n\nexport const EVAL_CHAT_PROMPT = /* #__PURE__ */ ChatPromptTemplate.fromMessages(\n  [\n    /* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate(\n      \"You are a helpful assistant that evaluates language models.\"\n    ),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),\n    /* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EVAL_TEMPLATE),\n  ]\n);\n\nconst TOOL_FREE_EVAL_TEMPLATE = `An AI language model has been given access to a set of tools to help answer a user's question.\n\nThe question the human asked the AI model was:\n[QUESTION]\n{question}\n[END_QUESTION]{reference}\n\nThe AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\n{agentTrajectory}\n[END_AGENT_TRAJECTORY]\n\nThe AI language model's final answer to the question was:\n[RESPONSE]\n{answer}\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\n    ii. Does the AI language use a logical sequence of tools to answer the question?\n    iii. Does the AI language model use the tools in a helpful way?\n    iv. Does the AI language model use too many steps to answer the question?\n    v. Are the appropriate tools used to answer the question?`;\n\nexport const TOOL_FREE_EVAL_CHAT_PROMPT =\n  /* #__PURE__ */ ChatPromptTemplate.fromMessages([\n    /* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate(\n      \"You are a helpful assistant that evaluates language models.\"\n    ),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),\n    /* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(\n      TOOL_FREE_EVAL_TEMPLATE\n    ),\n  ]);\n"],"mappings":";;;;AAWA,MAAM,gBAAgB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDA8BkC,CAAC;AAE1D,MAAM,gBAAgB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDA2CkC,CAAC;AAE1D,MAAM,iBAAiB,CAAC;;;;;;;;;QAShB,CAAC;AAET,MAAa,mCAAmCA,4CAAmB,aACjE;iBACkBC,qDAA4B,aAC1C,8DACD;iBACeC,oDAA2B,aAAa,cAAc;iBACtDC,iDAAwB,aAAa,eAAe;iBACpDD,oDAA2B,aAAa,cAAc;AACvE,EACF;AAED,MAAM,0BAA0B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;6DAyB4B,CAAC;AAE9D,MAAa,6CACKF,4CAAmB,aAAa;iBAC9BC,qDAA4B,aAC1C,8DACD;iBACeC,oDAA2B,aAAa,cAAc;iBACtDC,iDAAwB,aAAa,eAAe;iBACpDD,oDAA2B,aACzC,wBACD;AACF,EAAC"}
+{"version":3,"file":"prompt.cjs","names":[],"sources":["../../../src/evaluation/agents/prompt.ts"],"sourcesContent":["/**\n * Prompt for trajectory evaluation chain.\n */\n\nimport {\n  AIMessagePromptTemplate,\n  ChatPromptTemplate,\n  HumanMessagePromptTemplate,\n  SystemMessagePromptTemplate,\n} from \"@langchain/core/prompts\";\n\nconst EVAL_TEMPLATE = `An AI language model has been given access to the following set of tools to help answer a user's question.\n\nThe tools given to the AI model are:\n[TOOL_DESCRIPTIONS]\n{toolDescriptions}\n[END_TOOL_DESCRIPTIONS]\n\nThe question the human asked the AI model was:\n[QUESTION]\n{question}\n[END_QUESTION]{reference}\n\nThe AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\n{agentTrajectory}\n[END_AGENT_TRAJECTORY]\n\nThe AI language model's final answer to the question was:\n[RESPONSE]\n{answer}\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\nii. Does the AI language use a logical sequence of tools to answer the question?\niii. Does the AI language model use the tools in a helpful way?\niv. Does the AI language model use too many steps to answer the question?\nv. Are the appropriate tools used to answer the question?`;\n\nconst EXAMPLE_INPUT = `An AI language model has been given access to the following set of tools to help answer a user's question.\n\nThe tools given to the AI model are:\n[TOOL_DESCRIPTIONS]\nTool 1:\nName: Search\nDescription: useful for when you need to ask with search\n\nTool 2:\nName: Lookup\nDescription: useful for when you need to ask with lookup\n\nTool 3:\nName: Calculator\nDescription: useful for doing calculations\n\nTool 4:\nName: Search the Web (SerpAPI)\nDescription: useful for when you need to answer questions about current events\n[END_TOOL_DESCRIPTIONS]\n\nThe question the human asked the AI model was: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?\n\n    The AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\nStep 1:\nTool used: Search the Web (SerpAPI)\nTool input: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?\nTool output: The Statue of Liberty was given to the United States by France, as a symbol of the two countries' friendship. It was erected atop an American-designed ...\n[END_AGENT_TRAJECTORY]\n\n[RESPONSE]\nThe AI language model's final answer to the question was: There are different ways to measure the length of the United States, but if we use the distance between the Statue of Liberty and the westernmost point of the contiguous United States (Cape Alava, Washington), which is approximately 2,857 miles (4,596 km), and assume that the Statue of Liberty is 305 feet (93 meters) tall, then the statue would stretch across the United States approximately 17.5 times if laid end to end.\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\nii. Does the AI language use a logical sequence of tools to answer the question?\niii. Does the AI language model use the tools in a helpful way?\niv. Does the AI language model use too many steps to answer the question?\nv. Are the appropriate tools used to answer the question?`;\n\nconst EXAMPLE_OUTPUT = `First, let's evaluate the final answer. The final uses good reasoning but is wrong. 2,857 divided by 305 is not 17.5.\\\nThe model should have used the calculator to figure this out. Second does the model use a logical sequence of tools to answer the question?\\\nThe way model uses the search is not helpful. The model should have used the search tool to figure the width of the US or the height of the statue.\\\nThe model didn't use the calculator tool and gave an incorrect answer. The search API should be used for current events or specific questions.\\\nThe tools were not used in a helpful way. The model did not use too many steps to answer the question.\\\nThe model did not use the appropriate tools to answer the question.\\\n\nJudgment: Given the good reasoning in the final answer but otherwise poor performance, we give the model a score of 2.\n\nScore: 2`;\n\nexport const EVAL_CHAT_PROMPT = /* #__PURE__ */ ChatPromptTemplate.fromMessages(\n  [\n    /* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate(\n      \"You are a helpful assistant that evaluates language models.\"\n    ),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),\n    /* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EVAL_TEMPLATE),\n  ]\n);\n\nconst TOOL_FREE_EVAL_TEMPLATE = `An AI language model has been given access to a set of tools to help answer a user's question.\n\nThe question the human asked the AI model was:\n[QUESTION]\n{question}\n[END_QUESTION]{reference}\n\nThe AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\n{agentTrajectory}\n[END_AGENT_TRAJECTORY]\n\nThe AI language model's final answer to the question was:\n[RESPONSE]\n{answer}\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\n    ii. Does the AI language use a logical sequence of tools to answer the question?\n    iii. Does the AI language model use the tools in a helpful way?\n    iv. Does the AI language model use too many steps to answer the question?\n    v. Are the appropriate tools used to answer the question?`;\n\nexport const TOOL_FREE_EVAL_CHAT_PROMPT =\n  /* #__PURE__ */ ChatPromptTemplate.fromMessages([\n    /* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate(\n      \"You are a helpful assistant that evaluates language models.\"\n    ),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),\n    /* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(\n      TOOL_FREE_EVAL_TEMPLATE\n    ),\n  ]);\n"],"mappings":";;;;;;;AAWA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCtB,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CtB,MAAM,iBAAiB;;;;;;;;;;AAWvB,MAAa,mBAAmC,2DAAmB,aACjE;CACkB,oEAA4B,aAC1C,8DACD;CACe,mEAA2B,aAAa,cAAc;CACtD,gEAAwB,aAAa,eAAe;CACpD,mEAA2B,aAAa,cAAc;CACvE,CACF;AAED,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BhC,MAAa,6BACK,2DAAmB,aAAa;CAC9B,oEAA4B,aAC1C,8DACD;CACe,mEAA2B,aAAa,cAAc;CACtD,gEAAwB,aAAa,eAAe;CACpD,mEAA2B,aACzC,wBACD;CACF,CAAC"}

package/dist/evaluation/agents/prompt.js

@@ -1,6 +1,9 @@
 import { AIMessagePromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate } from "@langchain/core/prompts";
 
 //#region src/evaluation/agents/prompt.ts
+/**
+* Prompt for trajectory evaluation chain.
+*/
 const EVAL_TEMPLATE = `An AI language model has been given access to the following set of tools to help answer a user's question.
 
 The tools given to the AI model are:

package/dist/evaluation/agents/prompt.js.map

@@ -1 +1 @@
-{"version":3,"file":"prompt.js","names":[],"sources":["../../../src/evaluation/agents/prompt.ts"],"sourcesContent":["/**\n * Prompt for trajectory evaluation chain.\n */\n\nimport {\n  AIMessagePromptTemplate,\n  ChatPromptTemplate,\n  HumanMessagePromptTemplate,\n  SystemMessagePromptTemplate,\n} from \"@langchain/core/prompts\";\n\nconst EVAL_TEMPLATE = `An AI language model has been given access to the following set of tools to help answer a user's question.\n\nThe tools given to the AI model are:\n[TOOL_DESCRIPTIONS]\n{toolDescriptions}\n[END_TOOL_DESCRIPTIONS]\n\nThe question the human asked the AI model was:\n[QUESTION]\n{question}\n[END_QUESTION]{reference}\n\nThe AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\n{agentTrajectory}\n[END_AGENT_TRAJECTORY]\n\nThe AI language model's final answer to the question was:\n[RESPONSE]\n{answer}\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\nii. Does the AI language use a logical sequence of tools to answer the question?\niii. Does the AI language model use the tools in a helpful way?\niv. Does the AI language model use too many steps to answer the question?\nv. Are the appropriate tools used to answer the question?`;\n\nconst EXAMPLE_INPUT = `An AI language model has been given access to the following set of tools to help answer a user's question.\n\nThe tools given to the AI model are:\n[TOOL_DESCRIPTIONS]\nTool 1:\nName: Search\nDescription: useful for when you need to ask with search\n\nTool 2:\nName: Lookup\nDescription: useful for when you need to ask with lookup\n\nTool 3:\nName: Calculator\nDescription: useful for doing calculations\n\nTool 4:\nName: Search the Web (SerpAPI)\nDescription: useful for when you need to answer questions about current events\n[END_TOOL_DESCRIPTIONS]\n\nThe question the human asked the AI model was: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?\n\n    The AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\nStep 1:\nTool used: Search the Web (SerpAPI)\nTool input: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?\nTool output: The Statue of Liberty was given to the United States by France, as a symbol of the two countries' friendship. It was erected atop an American-designed ...\n[END_AGENT_TRAJECTORY]\n\n[RESPONSE]\nThe AI language model's final answer to the question was: There are different ways to measure the length of the United States, but if we use the distance between the Statue of Liberty and the westernmost point of the contiguous United States (Cape Alava, Washington), which is approximately 2,857 miles (4,596 km), and assume that the Statue of Liberty is 305 feet (93 meters) tall, then the statue would stretch across the United States approximately 17.5 times if laid end to end.\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\nii. Does the AI language use a logical sequence of tools to answer the question?\niii. Does the AI language model use the tools in a helpful way?\niv. Does the AI language model use too many steps to answer the question?\nv. Are the appropriate tools used to answer the question?`;\n\nconst EXAMPLE_OUTPUT = `First, let's evaluate the final answer. The final uses good reasoning but is wrong. 2,857 divided by 305 is not 17.5.\\\nThe model should have used the calculator to figure this out. Second does the model use a logical sequence of tools to answer the question?\\\nThe way model uses the search is not helpful. The model should have used the search tool to figure the width of the US or the height of the statue.\\\nThe model didn't use the calculator tool and gave an incorrect answer. The search API should be used for current events or specific questions.\\\nThe tools were not used in a helpful way. The model did not use too many steps to answer the question.\\\nThe model did not use the appropriate tools to answer the question.\\\n\nJudgment: Given the good reasoning in the final answer but otherwise poor performance, we give the model a score of 2.\n\nScore: 2`;\n\nexport const EVAL_CHAT_PROMPT = /* #__PURE__ */ ChatPromptTemplate.fromMessages(\n  [\n    /* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate(\n      \"You are a helpful assistant that evaluates language models.\"\n    ),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),\n    /* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EVAL_TEMPLATE),\n  ]\n);\n\nconst TOOL_FREE_EVAL_TEMPLATE = `An AI language model has been given access to a set of tools to help answer a user's question.\n\nThe question the human asked the AI model was:\n[QUESTION]\n{question}\n[END_QUESTION]{reference}\n\nThe AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\n{agentTrajectory}\n[END_AGENT_TRAJECTORY]\n\nThe AI language model's final answer to the question was:\n[RESPONSE]\n{answer}\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\n    ii. Does the AI language use a logical sequence of tools to answer the question?\n    iii. Does the AI language model use the tools in a helpful way?\n    iv. Does the AI language model use too many steps to answer the question?\n    v. Are the appropriate tools used to answer the question?`;\n\nexport const TOOL_FREE_EVAL_CHAT_PROMPT =\n  /* #__PURE__ */ ChatPromptTemplate.fromMessages([\n    /* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate(\n      \"You are a helpful assistant that evaluates language models.\"\n    ),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),\n    /* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(\n      TOOL_FREE_EVAL_TEMPLATE\n    ),\n  ]);\n"],"mappings":";;;AAWA,MAAM,gBAAgB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDA8BkC,CAAC;AAE1D,MAAM,gBAAgB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDA2CkC,CAAC;AAE1D,MAAM,iBAAiB,CAAC;;;;;;;;;QAShB,CAAC;AAET,MAAa,mCAAmC,mBAAmB,aACjE;iBACkB,4BAA4B,aAC1C,8DACD;iBACe,2BAA2B,aAAa,cAAc;iBACtD,wBAAwB,aAAa,eAAe;iBACpD,2BAA2B,aAAa,cAAc;AACvE,EACF;AAED,MAAM,0BAA0B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;6DAyB4B,CAAC;AAE9D,MAAa,6CACK,mBAAmB,aAAa;iBAC9B,4BAA4B,aAC1C,8DACD;iBACe,2BAA2B,aAAa,cAAc;iBACtD,wBAAwB,aAAa,eAAe;iBACpD,2BAA2B,aACzC,wBACD;AACF,EAAC"}
+{"version":3,"file":"prompt.js","names":[],"sources":["../../../src/evaluation/agents/prompt.ts"],"sourcesContent":["/**\n * Prompt for trajectory evaluation chain.\n */\n\nimport {\n  AIMessagePromptTemplate,\n  ChatPromptTemplate,\n  HumanMessagePromptTemplate,\n  SystemMessagePromptTemplate,\n} from \"@langchain/core/prompts\";\n\nconst EVAL_TEMPLATE = `An AI language model has been given access to the following set of tools to help answer a user's question.\n\nThe tools given to the AI model are:\n[TOOL_DESCRIPTIONS]\n{toolDescriptions}\n[END_TOOL_DESCRIPTIONS]\n\nThe question the human asked the AI model was:\n[QUESTION]\n{question}\n[END_QUESTION]{reference}\n\nThe AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\n{agentTrajectory}\n[END_AGENT_TRAJECTORY]\n\nThe AI language model's final answer to the question was:\n[RESPONSE]\n{answer}\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\nii. Does the AI language use a logical sequence of tools to answer the question?\niii. Does the AI language model use the tools in a helpful way?\niv. Does the AI language model use too many steps to answer the question?\nv. Are the appropriate tools used to answer the question?`;\n\nconst EXAMPLE_INPUT = `An AI language model has been given access to the following set of tools to help answer a user's question.\n\nThe tools given to the AI model are:\n[TOOL_DESCRIPTIONS]\nTool 1:\nName: Search\nDescription: useful for when you need to ask with search\n\nTool 2:\nName: Lookup\nDescription: useful for when you need to ask with lookup\n\nTool 3:\nName: Calculator\nDescription: useful for doing calculations\n\nTool 4:\nName: Search the Web (SerpAPI)\nDescription: useful for when you need to answer questions about current events\n[END_TOOL_DESCRIPTIONS]\n\nThe question the human asked the AI model was: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?\n\n    The AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\nStep 1:\nTool used: Search the Web (SerpAPI)\nTool input: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?\nTool output: The Statue of Liberty was given to the United States by France, as a symbol of the two countries' friendship. It was erected atop an American-designed ...\n[END_AGENT_TRAJECTORY]\n\n[RESPONSE]\nThe AI language model's final answer to the question was: There are different ways to measure the length of the United States, but if we use the distance between the Statue of Liberty and the westernmost point of the contiguous United States (Cape Alava, Washington), which is approximately 2,857 miles (4,596 km), and assume that the Statue of Liberty is 305 feet (93 meters) tall, then the statue would stretch across the United States approximately 17.5 times if laid end to end.\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\nii. Does the AI language use a logical sequence of tools to answer the question?\niii. Does the AI language model use the tools in a helpful way?\niv. Does the AI language model use too many steps to answer the question?\nv. Are the appropriate tools used to answer the question?`;\n\nconst EXAMPLE_OUTPUT = `First, let's evaluate the final answer. The final uses good reasoning but is wrong. 2,857 divided by 305 is not 17.5.\\\nThe model should have used the calculator to figure this out. Second does the model use a logical sequence of tools to answer the question?\\\nThe way model uses the search is not helpful. The model should have used the search tool to figure the width of the US or the height of the statue.\\\nThe model didn't use the calculator tool and gave an incorrect answer. The search API should be used for current events or specific questions.\\\nThe tools were not used in a helpful way. The model did not use too many steps to answer the question.\\\nThe model did not use the appropriate tools to answer the question.\\\n\nJudgment: Given the good reasoning in the final answer but otherwise poor performance, we give the model a score of 2.\n\nScore: 2`;\n\nexport const EVAL_CHAT_PROMPT = /* #__PURE__ */ ChatPromptTemplate.fromMessages(\n  [\n    /* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate(\n      \"You are a helpful assistant that evaluates language models.\"\n    ),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),\n    /* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EVAL_TEMPLATE),\n  ]\n);\n\nconst TOOL_FREE_EVAL_TEMPLATE = `An AI language model has been given access to a set of tools to help answer a user's question.\n\nThe question the human asked the AI model was:\n[QUESTION]\n{question}\n[END_QUESTION]{reference}\n\nThe AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\n{agentTrajectory}\n[END_AGENT_TRAJECTORY]\n\nThe AI language model's final answer to the question was:\n[RESPONSE]\n{answer}\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\n    ii. Does the AI language use a logical sequence of tools to answer the question?\n    iii. Does the AI language model use the tools in a helpful way?\n    iv. Does the AI language model use too many steps to answer the question?\n    v. Are the appropriate tools used to answer the question?`;\n\nexport const TOOL_FREE_EVAL_CHAT_PROMPT =\n  /* #__PURE__ */ ChatPromptTemplate.fromMessages([\n    /* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate(\n      \"You are a helpful assistant that evaluates language models.\"\n    ),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),\n    /* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(\n      TOOL_FREE_EVAL_TEMPLATE\n    ),\n  ]);\n"],"mappings":";;;;;;AAWA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCtB,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CtB,MAAM,iBAAiB;;;;;;;;;;AAWvB,MAAa,mBAAmC,mCAAmB,aACjE;CACkB,4CAA4B,aAC1C,8DACD;CACe,2CAA2B,aAAa,cAAc;CACtD,wCAAwB,aAAa,eAAe;CACpD,2CAA2B,aAAa,cAAc;CACvE,CACF;AAED,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BhC,MAAa,6BACK,mCAAmB,aAAa;CAC9B,4CAA4B,aAC1C,8DACD;CACe,2CAA2B,aAAa,cAAc;CACtD,wCAAwB,aAAa,eAAe;CACpD,2CAA2B,aACzC,wBACD;CACF,CAAC"}

package/dist/evaluation/agents/trajectory.cjs

@@ -1,14 +1,14 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
 const require_base = require('../base.cjs');
 const require_prompt = require('./prompt.cjs');
-const __langchain_core_outputs = require_rolldown_runtime.__toESM(require("@langchain/core/outputs"));
-const __langchain_core_output_parsers = require_rolldown_runtime.__toESM(require("@langchain/core/output_parsers"));
+let _langchain_core_outputs = require("@langchain/core/outputs");
+let _langchain_core_output_parsers = require("@langchain/core/output_parsers");
 
 //#region src/evaluation/agents/trajectory.ts
 /**
 * A parser for the output of the TrajectoryEvalChain.
 */
-var TrajectoryOutputParser = class extends __langchain_core_output_parsers.BaseLLMOutputParser {
+var TrajectoryOutputParser = class extends _langchain_core_output_parsers.BaseLLMOutputParser {
 	static lc_name() {
 		return "TrajectoryOutputParser";
 	}
@@ -86,7 +86,7 @@ var TrajectoryEvalChain = class extends require_base.AgentTrajectoryEvaluator {
 	}
 	_prepareOutput(result) {
 		const parsed = result[this.outputKey];
-		if (__langchain_core_outputs.RUN_KEY in result && result[__langchain_core_outputs.RUN_KEY]) parsed[__langchain_core_outputs.RUN_KEY] = result[__langchain_core_outputs.RUN_KEY];
+		if (_langchain_core_outputs.RUN_KEY in result && result[_langchain_core_outputs.RUN_KEY]) parsed[_langchain_core_outputs.RUN_KEY] = result[_langchain_core_outputs.RUN_KEY];
 		return parsed;
 	}
 	/**

package/dist/evaluation/agents/trajectory.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"trajectory.cjs","names":["BaseLLMOutputParser","generations: Generation[] | ChatGeneration[]","_callbacks: Callbacks | undefined","AgentTrajectoryEvaluator","prompt?: BasePromptTemplate | undefined","agentTools?: StructuredToolInterface[]","EVAL_CHAT_PROMPT","TOOL_FREE_EVAL_CHAT_PROMPT","agentTools: StructuredToolInterface[]","llm: BaseChatModel","chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>","result: ChainValues","RUN_KEY","steps: AgentStep[]","reference?: string","args: LLMTrajectoryEvaluatorArgs","callOptions: ExtractLLMCallOptions<this[\"llm\"]>","config?: Callbacks | BaseCallbackConfig"],"sources":["../../../src/evaluation/agents/trajectory.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\n\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation, RUN_KEY } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport {\n  Callbacks,\n  BaseCallbackConfig,\n} from \"@langchain/core/callbacks/manager\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport {\n  AgentTrajectoryEvaluator,\n  EvalOutputType,\n  LLMEvalChainInput,\n  LLMTrajectoryEvaluatorArgs,\n  type ExtractLLMCallOptions,\n} from \"../base.js\";\nimport { EVAL_CHAT_PROMPT, TOOL_FREE_EVAL_CHAT_PROMPT } from \"./prompt.js\";\n\n/**\n * A parser for the output of the TrajectoryEvalChain.\n */\nexport class TrajectoryOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n  static lc_name(): string {\n    return \"TrajectoryOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"evaluation\", \"agents\"];\n\n  parseResult(\n    generations: Generation[] | ChatGeneration[],\n    _callbacks: Callbacks | undefined\n  ): Promise<EvalOutputType> {\n    const { text } = generations[0];\n\n    if (!text.includes(\"Score:\")) {\n      throw new Error(`Could not find score in model eval output: ${text}`);\n    }\n\n    let [reasoning, scoreStr] = text.split(\"Score:\", 2);\n    reasoning = reasoning.trim();\n    scoreStr = scoreStr.trim();\n\n    // Use regex to extract the score.\n    // This will get the number in the string, even if it is a float or more than 10.\n    // E.g. \"Score: 1\" will return 1, \"Score: 3.5\" will return 3.5, and\n    // \"Score: 10\" will return 10.\n    // The score should be an integer digit in the range 1-5.\n\n    const scoreMatch = scoreStr.match(/(\\d+(\\.\\d+)?)/);\n    if (scoreMatch === null || scoreMatch[1].includes(\".\")) {\n      throw new Error(\n        `Score is not an integer digit in the range 1-5: ${text}`\n      );\n    }\n\n    const score = +scoreMatch[1];\n    if (score < 1 || score > 5) {\n      throw new Error(`Score is not a digit in the range 1-5: ${text}`);\n    }\n\n    const normalizedScore = (score - 1) / 4;\n\n    return Promise.resolve({\n      reasoning,\n      score: normalizedScore,\n    });\n  }\n}\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 class TrajectoryEvalChain extends AgentTrajectoryEvaluator {\n  static lc_name(): string {\n    return \"TrajectoryEvalChain\";\n  }\n\n  criterionName?: string;\n\n  evaluationName?: string = this.criterionName;\n\n  requiresInput = true;\n\n  requiresReference = false;\n\n  outputParser = new TrajectoryOutputParser();\n\n  static resolveTrajectoryPrompt(\n    prompt?: BasePromptTemplate | undefined,\n    agentTools?: StructuredToolInterface[]\n  ) {\n    let _prompt;\n    if (prompt) {\n      _prompt = prompt;\n    } else if (agentTools) {\n      _prompt = EVAL_CHAT_PROMPT;\n    } else {\n      _prompt = TOOL_FREE_EVAL_CHAT_PROMPT;\n    }\n\n    return _prompt;\n  }\n\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    return agentTools\n      .map(\n        (tool, i) =>\n          `Tool ${i + 1}: ${tool.name}\\n Description: ${tool.description}`\n      )\n      .join(\"\\n\\n\");\n  }\n\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 async fromLLM(\n    llm: BaseChatModel,\n    agentTools?: StructuredToolInterface[],\n    chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>\n  ) {\n    let prompt = this.resolveTrajectoryPrompt(chainOptions?.prompt, agentTools);\n    if (agentTools) {\n      const toolDescriptions = this.toolsDescription(agentTools);\n      prompt = await prompt.partial({ toolDescriptions });\n    }\n\n    const options = chainOptions;\n    if (options) {\n      // remove prompt from chainOptions\n      delete options.prompt;\n    }\n\n    return new this({\n      llm,\n      prompt,\n      ...options,\n    });\n  }\n\n  _prepareOutput(result: ChainValues) {\n    const parsed = result[this.outputKey];\n    if (RUN_KEY in result && result[RUN_KEY]) {\n      parsed[RUN_KEY] = result[RUN_KEY];\n    }\n    return parsed;\n  }\n\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    return steps\n      .map((step, i) => {\n        const { action, observation } = step;\n\n        return (\n          `Step ${i + 1}:\\n` +\n          `Tool used: ${action.tool}\\n` +\n          `Tool input: ${action.toolInput}\\n` +\n          `Tool output: ${observation}`\n        );\n      })\n      .join(\"\\n\\n\");\n  }\n\n  formatReference(reference?: string): string {\n    if (!reference) {\n      return \"\";\n    }\n    return `\nThe following is the expected answer. Use this to measure correctness:\n[GROUND_TRUTH]\n${reference}\n[END_GROUND_TRUTH]\n        `;\n  }\n\n  async _evaluateAgentTrajectory(\n    args: LLMTrajectoryEvaluatorArgs,\n    callOptions: ExtractLLMCallOptions<this[\"llm\"]>,\n    config?: Callbacks | BaseCallbackConfig\n  ): Promise<ChainValues> {\n    const { input, prediction, reference, agentTrajectory } = args;\n\n    const inputs = {\n      question: input,\n      agentTrajectory: this.getAgentTrajectory(agentTrajectory),\n      answer: prediction,\n      reference: this.formatReference(reference),\n    };\n\n    const result = await this.call({ ...inputs, ...callOptions }, config);\n\n    return this._prepareOutput(result);\n  }\n}\n"],"mappings":";;;;;;;;;;AAwBA,IAAa,yBAAb,cAA4CA,oDAAoC;CAC9E,OAAO,UAAkB;AACvB,SAAO;CACR;CAED,eAAe;EAAC;EAAa;EAAc;CAAS;CAEpD,YACEC,aACAC,YACyB;EACzB,MAAM,EAAE,MAAM,GAAG,YAAY;AAE7B,MAAI,CAAC,KAAK,SAAS,SAAS,CAC1B,OAAM,IAAI,MAAM,CAAC,2CAA2C,EAAE,MAAM;EAGtE,IAAI,CAAC,WAAW,SAAS,GAAG,KAAK,MAAM,UAAU,EAAE;EACnD,YAAY,UAAU,MAAM;EAC5B,WAAW,SAAS,MAAM;EAQ1B,MAAM,aAAa,SAAS,MAAM,gBAAgB;AAClD,MAAI,eAAe,QAAQ,WAAW,GAAG,SAAS,IAAI,CACpD,OAAM,IAAI,MACR,CAAC,gDAAgD,EAAE,MAAM;EAI7D,MAAM,QAAQ,CAAC,WAAW;AAC1B,MAAI,QAAQ,KAAK,QAAQ,EACvB,OAAM,IAAI,MAAM,CAAC,uCAAuC,EAAE,MAAM;EAGlE,MAAM,mBAAmB,QAAQ,KAAK;AAEtC,SAAO,QAAQ,QAAQ;GACrB;GACA,OAAO;EACR,EAAC;CACH;AACF;;;;;;;AAQD,IAAa,sBAAb,cAAyCC,sCAAyB;CAChE,OAAO,UAAkB;AACvB,SAAO;CACR;CAED;CAEA,iBAA0B,KAAK;CAE/B,gBAAgB;CAEhB,oBAAoB;CAEpB,eAAe,IAAI;CAEnB,OAAO,wBACLC,QACAC,YACA;EACA,IAAI;AACJ,MAAI,QACF,UAAU;WACD,YACT,UAAUC;OAEV,UAAUC;AAGZ,SAAO;CACR;;;;;;CAOD,OAAO,iBAAiBC,YAA+C;AACrE,SAAO,WACJ,IACC,CAAC,MAAM,MACL,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,KAAK,gBAAgB,EAAE,KAAK,aAAa,CACnE,CACA,KAAK,OAAO;CAChB;;;;;;;CAQD,aAAa,QACXC,KACAJ,YACAK,cACA;EACA,IAAI,SAAS,KAAK,wBAAwB,cAAc,QAAQ,WAAW;AAC3E,MAAI,YAAY;GACd,MAAM,mBAAmB,KAAK,iBAAiB,WAAW;GAC1D,SAAS,MAAM,OAAO,QAAQ,EAAE,iBAAkB,EAAC;EACpD;EAED,MAAM,UAAU;AAChB,MAAI,SAEF,OAAO,QAAQ;AAGjB,SAAO,IAAI,KAAK;GACd;GACA;GACA,GAAG;EACJ;CACF;CAED,eAAeC,QAAqB;EAClC,MAAM,SAAS,OAAO,KAAK;AAC3B,MAAIC,oCAAW,UAAU,OAAOA,mCAC9B,OAAOA,oCAAW,OAAOA;AAE3B,SAAO;CACR;;;;;;;CAQD,mBAAmBC,OAA4B;AAC7C,SAAO,MACJ,IAAI,CAAC,MAAM,MAAM;GAChB,MAAM,EAAE,QAAQ,aAAa,GAAG;AAEhC,UACE,CAAC,KAAK,EAAE,IAAI,EAAE,cAAG,EACH,OAAO,KAAK,cAAE,EACb,OAAO,UAAU,eAAE,EAClB,aAAa;EAEhC,EAAC,CACD,KAAK,OAAO;CAChB;CAED,gBAAgBC,WAA4B;AAC1C,MAAI,CAAC,UACH,QAAO;AAET,SAAO,CAAC;;;AAGZ,EAAE,UAAU;;QAEJ,CAAC;CACN;CAED,MAAM,yBACJC,MACAC,aACAC,QACsB;EACtB,MAAM,EAAE,OAAO,YAAY,WAAW,iBAAiB,GAAG;EAE1D,MAAM,SAAS;GACb,UAAU;GACV,iBAAiB,KAAK,mBAAmB,gBAAgB;GACzD,QAAQ;GACR,WAAW,KAAK,gBAAgB,UAAU;EAC3C;EAED,MAAM,SAAS,MAAM,KAAK,KAAK;GAAE,GAAG;GAAQ,GAAG;EAAa,GAAE,OAAO;AAErE,SAAO,KAAK,eAAe,OAAO;CACnC;AACF"}
+{"version":3,"file":"trajectory.cjs","names":["BaseLLMOutputParser","AgentTrajectoryEvaluator","EVAL_CHAT_PROMPT","TOOL_FREE_EVAL_CHAT_PROMPT","RUN_KEY"],"sources":["../../../src/evaluation/agents/trajectory.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\n\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation, RUN_KEY } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport {\n  Callbacks,\n  BaseCallbackConfig,\n} from \"@langchain/core/callbacks/manager\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport {\n  AgentTrajectoryEvaluator,\n  EvalOutputType,\n  LLMEvalChainInput,\n  LLMTrajectoryEvaluatorArgs,\n  type ExtractLLMCallOptions,\n} from \"../base.js\";\nimport { EVAL_CHAT_PROMPT, TOOL_FREE_EVAL_CHAT_PROMPT } from \"./prompt.js\";\n\n/**\n * A parser for the output of the TrajectoryEvalChain.\n */\nexport class TrajectoryOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n  static lc_name(): string {\n    return \"TrajectoryOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"evaluation\", \"agents\"];\n\n  parseResult(\n    generations: Generation[] | ChatGeneration[],\n    _callbacks: Callbacks | undefined\n  ): Promise<EvalOutputType> {\n    const { text } = generations[0];\n\n    if (!text.includes(\"Score:\")) {\n      throw new Error(`Could not find score in model eval output: ${text}`);\n    }\n\n    let [reasoning, scoreStr] = text.split(\"Score:\", 2);\n    reasoning = reasoning.trim();\n    scoreStr = scoreStr.trim();\n\n    // Use regex to extract the score.\n    // This will get the number in the string, even if it is a float or more than 10.\n    // E.g. \"Score: 1\" will return 1, \"Score: 3.5\" will return 3.5, and\n    // \"Score: 10\" will return 10.\n    // The score should be an integer digit in the range 1-5.\n\n    const scoreMatch = scoreStr.match(/(\\d+(\\.\\d+)?)/);\n    if (scoreMatch === null || scoreMatch[1].includes(\".\")) {\n      throw new Error(\n        `Score is not an integer digit in the range 1-5: ${text}`\n      );\n    }\n\n    const score = +scoreMatch[1];\n    if (score < 1 || score > 5) {\n      throw new Error(`Score is not a digit in the range 1-5: ${text}`);\n    }\n\n    const normalizedScore = (score - 1) / 4;\n\n    return Promise.resolve({\n      reasoning,\n      score: normalizedScore,\n    });\n  }\n}\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 class TrajectoryEvalChain extends AgentTrajectoryEvaluator {\n  static lc_name(): string {\n    return \"TrajectoryEvalChain\";\n  }\n\n  criterionName?: string;\n\n  evaluationName?: string = this.criterionName;\n\n  requiresInput = true;\n\n  requiresReference = false;\n\n  outputParser = new TrajectoryOutputParser();\n\n  static resolveTrajectoryPrompt(\n    prompt?: BasePromptTemplate | undefined,\n    agentTools?: StructuredToolInterface[]\n  ) {\n    let _prompt;\n    if (prompt) {\n      _prompt = prompt;\n    } else if (agentTools) {\n      _prompt = EVAL_CHAT_PROMPT;\n    } else {\n      _prompt = TOOL_FREE_EVAL_CHAT_PROMPT;\n    }\n\n    return _prompt;\n  }\n\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    return agentTools\n      .map(\n        (tool, i) =>\n          `Tool ${i + 1}: ${tool.name}\\n Description: ${tool.description}`\n      )\n      .join(\"\\n\\n\");\n  }\n\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 async fromLLM(\n    llm: BaseChatModel,\n    agentTools?: StructuredToolInterface[],\n    chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>\n  ) {\n    let prompt = this.resolveTrajectoryPrompt(chainOptions?.prompt, agentTools);\n    if (agentTools) {\n      const toolDescriptions = this.toolsDescription(agentTools);\n      prompt = await prompt.partial({ toolDescriptions });\n    }\n\n    const options = chainOptions;\n    if (options) {\n      // remove prompt from chainOptions\n      delete options.prompt;\n    }\n\n    return new this({\n      llm,\n      prompt,\n      ...options,\n    });\n  }\n\n  _prepareOutput(result: ChainValues) {\n    const parsed = result[this.outputKey];\n    if (RUN_KEY in result && result[RUN_KEY]) {\n      parsed[RUN_KEY] = result[RUN_KEY];\n    }\n    return parsed;\n  }\n\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    return steps\n      .map((step, i) => {\n        const { action, observation } = step;\n\n        return (\n          `Step ${i + 1}:\\n` +\n          `Tool used: ${action.tool}\\n` +\n          `Tool input: ${action.toolInput}\\n` +\n          `Tool output: ${observation}`\n        );\n      })\n      .join(\"\\n\\n\");\n  }\n\n  formatReference(reference?: string): string {\n    if (!reference) {\n      return \"\";\n    }\n    return `\nThe following is the expected answer. Use this to measure correctness:\n[GROUND_TRUTH]\n${reference}\n[END_GROUND_TRUTH]\n        `;\n  }\n\n  async _evaluateAgentTrajectory(\n    args: LLMTrajectoryEvaluatorArgs,\n    callOptions: ExtractLLMCallOptions<this[\"llm\"]>,\n    config?: Callbacks | BaseCallbackConfig\n  ): Promise<ChainValues> {\n    const { input, prediction, reference, agentTrajectory } = args;\n\n    const inputs = {\n      question: input,\n      agentTrajectory: this.getAgentTrajectory(agentTrajectory),\n      answer: prediction,\n      reference: this.formatReference(reference),\n    };\n\n    const result = await this.call({ ...inputs, ...callOptions }, config);\n\n    return this._prepareOutput(result);\n  }\n}\n"],"mappings":";;;;;;;;;;AAwBA,IAAa,yBAAb,cAA4CA,mDAAoC;CAC9E,OAAO,UAAkB;AACvB,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAc;EAAS;CAEpD,YACE,aACA,YACyB;EACzB,MAAM,EAAE,SAAS,YAAY;AAE7B,MAAI,CAAC,KAAK,SAAS,SAAS,CAC1B,OAAM,IAAI,MAAM,8CAA8C,OAAO;EAGvE,IAAI,CAAC,WAAW,YAAY,KAAK,MAAM,UAAU,EAAE;AACnD,cAAY,UAAU,MAAM;AAC5B,aAAW,SAAS,MAAM;EAQ1B,MAAM,aAAa,SAAS,MAAM,gBAAgB;AAClD,MAAI,eAAe,QAAQ,WAAW,GAAG,SAAS,IAAI,CACpD,OAAM,IAAI,MACR,mDAAmD,OACpD;EAGH,MAAM,QAAQ,CAAC,WAAW;AAC1B,MAAI,QAAQ,KAAK,QAAQ,EACvB,OAAM,IAAI,MAAM,0CAA0C,OAAO;EAGnE,MAAM,mBAAmB,QAAQ,KAAK;AAEtC,SAAO,QAAQ,QAAQ;GACrB;GACA,OAAO;GACR,CAAC;;;;;;;;;AAUN,IAAa,sBAAb,cAAyCC,sCAAyB;CAChE,OAAO,UAAkB;AACvB,SAAO;;CAGT;CAEA,iBAA0B,KAAK;CAE/B,gBAAgB;CAEhB,oBAAoB;CAEpB,eAAe,IAAI,wBAAwB;CAE3C,OAAO,wBACL,QACA,YACA;EACA,IAAI;AACJ,MAAI,OACF,WAAU;WACD,WACT,WAAUC;MAEV,WAAUC;AAGZ,SAAO;;;;;;;CAQT,OAAO,iBAAiB,YAA+C;AACrE,SAAO,WACJ,KACE,MAAM,MACL,QAAQ,IAAI,EAAE,IAAI,KAAK,KAAK,kBAAkB,KAAK,cACtD,CACA,KAAK,OAAO;;;;;;;;CASjB,aAAa,QACX,KACA,YACA,cACA;EACA,IAAI,SAAS,KAAK,wBAAwB,cAAc,QAAQ,WAAW;AAC3E,MAAI,YAAY;GACd,MAAM,mBAAmB,KAAK,iBAAiB,WAAW;AAC1D,YAAS,MAAM,OAAO,QAAQ,EAAE,kBAAkB,CAAC;;EAGrD,MAAM,UAAU;AAChB,MAAI,QAEF,QAAO,QAAQ;AAGjB,SAAO,IAAI,KAAK;GACd;GACA;GACA,GAAG;GACJ,CAAC;;CAGJ,eAAe,QAAqB;EAClC,MAAM,SAAS,OAAO,KAAK;AAC3B,MAAIC,mCAAW,UAAU,OAAOA,iCAC9B,QAAOA,mCAAW,OAAOA;AAE3B,SAAO;;;;;;;;CAST,mBAAmB,OAA4B;AAC7C,SAAO,MACJ,KAAK,MAAM,MAAM;GAChB,MAAM,EAAE,QAAQ,gBAAgB;AAEhC,UACE,QAAQ,IAAI,EAAE,gBACA,OAAO,KAAK,gBACX,OAAO,UAAU,iBAChB;IAElB,CACD,KAAK,OAAO;;CAGjB,gBAAgB,WAA4B;AAC1C,MAAI,CAAC,UACH,QAAO;AAET,SAAO;;;EAGT,UAAU;;;;CAKV,MAAM,yBACJ,MACA,aACA,QACsB;EACtB,MAAM,EAAE,OAAO,YAAY,WAAW,oBAAoB;EAE1D,MAAM,SAAS;GACb,UAAU;GACV,iBAAiB,KAAK,mBAAmB,gBAAgB;GACzD,QAAQ;GACR,WAAW,KAAK,gBAAgB,UAAU;GAC3C;EAED,MAAM,SAAS,MAAM,KAAK,KAAK;GAAE,GAAG;GAAQ,GAAG;GAAa,EAAE,OAAO;AAErE,SAAO,KAAK,eAAe,OAAO"}