@langchain/core 1.1.4 → 1.1.5-dev-1765432861398

package/dist/prompts/serde.d.ts

@@ -32,7 +32,6 @@ type SerializedPromptTemplate = {
 type SerializedFewShotTemplate = {
   _type: "few_shot";
   input_variables: string[];
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   examples: string | any[];
   example_prompt?: SerializedPromptTemplate;
   example_separator: string;

package/dist/prompts/serde.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serde.d.ts","names":["MessageContent","TemplateFormat","SerializedPromptTemplate","SerializedFewShotTemplate","SerializedBasePromptTemplate"],"sources":["../../src/prompts/serde.d.ts"],"sourcesContent":["import { MessageContent } from \"../messages/index.js\";\nimport type { TemplateFormat } from \"./template.js\";\n/**\n * Represents a serialized version of a prompt template. This type is used\n * to create dynamic prompts for language models. It contains an optional\n * `_type` field which, if present, is set to 'prompt'. It also includes\n * `input_variables`, an array of strings representing the variables to be\n * used in the prompt, an optional `template_format` specifying the format\n * of the template, and an optional `template` which is the actual\n * template string.\n */\nexport type SerializedPromptTemplate = {\n    _type?: \"prompt\";\n    input_variables: string[];\n    template_format?: TemplateFormat;\n    template?: MessageContent;\n};\n/**\n * Represents a serialized version of a few-shot template. This type\n * includes an `_type` field set to 'few_shot', `input_variables` which\n * are an array of strings representing the variables to be used in the\n * template, `examples` which can be a string or an array of Example\n * objects, an optional `example_prompt` which is a\n * SerializedPromptTemplate, `example_separator` which is a string,\n * optional `prefix` and `suffix` strings, and `template_format` which\n * specifies the format of the template.\n */\nexport type SerializedFewShotTemplate = {\n    _type: \"few_shot\";\n    input_variables: string[];\n    examples: string | any[];\n    example_prompt?: SerializedPromptTemplate;\n    example_separator: string;\n    prefix?: string;\n    suffix?: string;\n    template_format: TemplateFormat;\n};\n/**\n * Represents a serialized version of a base prompt template. This type\n * can be either a SerializedFewShotTemplate or a\n * SerializedPromptTemplate.\n */\nexport type SerializedBasePromptTemplate = SerializedFewShotTemplate | SerializedPromptTemplate;\n//# sourceMappingURL=serde.d.ts.map"],"mappings":";;;;;;;;;AAWA;AAgBA;AAeA;;;;KA/BYE,wBAAAA;;;oBAGUD;aACPD;;;;;;;;;;;;KAYHG,yBAAAA;;;;mBAISD;;;;mBAIAD;;;;;;;KAOTG,4BAAAA,GAA+BD,4BAA4BD"}

package/dist/prompts/string.d.cts

@@ -9,11 +9,7 @@ import { BasePromptTemplate, TypedPromptInputValues } from "./base.cjs";
  * BasePromptTemplate class and overrides the formatPromptValue method to
  * return a StringPromptValue.
  */
-declare abstract class BaseStringPromptTemplate<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunInput extends InputValues = any,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-PartialVariableName extends string = any> extends BasePromptTemplate<RunInput, StringPromptValueInterface, PartialVariableName> {
+declare abstract class BaseStringPromptTemplate<RunInput extends InputValues = any, PartialVariableName extends string = any> extends BasePromptTemplate<RunInput, StringPromptValueInterface, PartialVariableName> {
   /**
    * Formats the prompt given the input values and returns a formatted
    * prompt value.

package/dist/prompts/string.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.cts","names":["InputValues","StringPromptValueInterface","BasePromptTemplate","TypedPromptInputValues","BaseStringPromptTemplate","RunInput","PartialVariableName","Promise"],"sources":["../../src/prompts/string.d.ts"],"sourcesContent":["import type { InputValues } from \"../utils/types/index.js\";\nimport { type StringPromptValueInterface } from \"../prompt_values.js\";\nimport { BasePromptTemplate, type TypedPromptInputValues } from \"./base.js\";\n/**\n * Base class for string prompt templates. It extends the\n * BasePromptTemplate class and overrides the formatPromptValue method to\n * return a StringPromptValue.\n */\nexport declare abstract class BaseStringPromptTemplate<RunInput extends InputValues = any, PartialVariableName extends string = any> extends BasePromptTemplate<RunInput, StringPromptValueInterface, PartialVariableName> {\n    /**\n     * Formats the prompt given the input values and returns a formatted\n     * prompt value.\n     * @param values The input values to format the prompt.\n     * @returns A Promise that resolves to a formatted prompt value.\n     */\n    formatPromptValue(values: TypedPromptInputValues<RunInput>): Promise<StringPromptValueInterface>;\n}\n//# sourceMappingURL=string.d.ts.map"],"mappings":";;;;;;;;AAQA;;;AAA0KC,uBAA5IG,wBAA4IH,CAAAA,iBAAlGD,WAAkGC,GAAAA,GAAAA,EAAAA,4BAAAA,MAAAA,GAAAA,GAAAA,CAAAA,SAA7BC,kBAA6BD,CAAVI,QAAUJ,EAAAA,0BAAAA,EAA4BK,mBAA5BL,CAAAA,CAAAA;EAA4BK;;;;;;EAAvC,iBAAA,CAAA,MAAA,EAOjIH,sBAPiI,CAO1GE,QAP0G,CAAA,CAAA,EAO9FE,OAP8F,CAOtFN,0BAPsF,CAAA"}

package/dist/prompts/string.d.ts

@@ -9,11 +9,7 @@ import { BasePromptTemplate, TypedPromptInputValues } from "./base.js";
  * BasePromptTemplate class and overrides the formatPromptValue method to
  * return a StringPromptValue.
  */
-declare abstract class BaseStringPromptTemplate<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunInput extends InputValues = any,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-PartialVariableName extends string = any> extends BasePromptTemplate<RunInput, StringPromptValueInterface, PartialVariableName> {
+declare abstract class BaseStringPromptTemplate<RunInput extends InputValues = any, PartialVariableName extends string = any> extends BasePromptTemplate<RunInput, StringPromptValueInterface, PartialVariableName> {
   /**
    * Formats the prompt given the input values and returns a formatted
    * prompt value.

package/dist/prompts/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","names":["InputValues","StringPromptValueInterface","BasePromptTemplate","TypedPromptInputValues","BaseStringPromptTemplate","RunInput","PartialVariableName","Promise"],"sources":["../../src/prompts/string.d.ts"],"sourcesContent":["import type { InputValues } from \"../utils/types/index.js\";\nimport { type StringPromptValueInterface } from \"../prompt_values.js\";\nimport { BasePromptTemplate, type TypedPromptInputValues } from \"./base.js\";\n/**\n * Base class for string prompt templates. It extends the\n * BasePromptTemplate class and overrides the formatPromptValue method to\n * return a StringPromptValue.\n */\nexport declare abstract class BaseStringPromptTemplate<RunInput extends InputValues = any, PartialVariableName extends string = any> extends BasePromptTemplate<RunInput, StringPromptValueInterface, PartialVariableName> {\n    /**\n     * Formats the prompt given the input values and returns a formatted\n     * prompt value.\n     * @param values The input values to format the prompt.\n     * @returns A Promise that resolves to a formatted prompt value.\n     */\n    formatPromptValue(values: TypedPromptInputValues<RunInput>): Promise<StringPromptValueInterface>;\n}\n//# sourceMappingURL=string.d.ts.map"],"mappings":";;;;;;;;AAQA;;;AAA0KC,uBAA5IG,wBAA4IH,CAAAA,iBAAlGD,WAAkGC,GAAAA,GAAAA,EAAAA,4BAAAA,MAAAA,GAAAA,GAAAA,CAAAA,SAA7BC,kBAA6BD,CAAVI,QAAUJ,EAAAA,0BAAAA,EAA4BK,mBAA5BL,CAAAA,CAAAA;EAA4BK;;;;;;EAAvC,iBAAA,CAAA,MAAA,EAOjIH,sBAPiI,CAO1GE,QAP0G,CAAA,CAAA,EAO9FE,OAP8F,CAOtFN,0BAPsF,CAAA"}

package/dist/prompts/structured.d.cts

@@ -9,31 +9,18 @@ import { BaseMessagePromptTemplateLike, ChatPromptTemplate, ChatPromptTemplateIn
 /**
  * Interface for the input of a ChatPromptTemplate.
  */
-interface StructuredPromptInput<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunInput extends InputValues = any,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-PartialVariableName extends string = any> extends ChatPromptTemplateInput<RunInput, PartialVariableName> {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+interface StructuredPromptInput<RunInput extends InputValues = any, PartialVariableName extends string = any> extends ChatPromptTemplateInput<RunInput, PartialVariableName> {
   schema: Record<string, any>;
   method?: "jsonMode" | "jsonSchema" | "functionMode";
 }
-declare class StructuredPrompt<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunInput extends InputValues = any,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-PartialVariableName extends string = any> extends ChatPromptTemplate<RunInput, PartialVariableName> implements StructuredPromptInput<RunInput, PartialVariableName> {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare class StructuredPrompt<RunInput extends InputValues = any, PartialVariableName extends string = any> extends ChatPromptTemplate<RunInput, PartialVariableName> implements StructuredPromptInput<RunInput, PartialVariableName> {
   schema: Record<string, any>;
   method?: "jsonMode" | "jsonSchema" | "functionMode";
   lc_namespace: string[];
   get lc_aliases(): Record<string, string>;
   constructor(input: StructuredPromptInput<RunInput, PartialVariableName>);
   pipe<NewRunOutput>(coerceable: RunnableLike<ChatPromptValueInterface, NewRunOutput>): Runnable<RunInput, Exclude<NewRunOutput, Error>, RunnableConfig>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  static fromMessagesAndSchema<RunInput extends InputValues = any>(promptMessages: (ChatPromptTemplate<InputValues, string> | BaseMessagePromptTemplateLike)[], schema: StructuredPromptInput["schema"], method?: "jsonMode" | "jsonSchema" | "functionMode"
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  ): ChatPromptTemplate<RunInput, any>;
+  static fromMessagesAndSchema<RunInput extends InputValues = any>(promptMessages: (ChatPromptTemplate<InputValues, string> | BaseMessagePromptTemplateLike)[], schema: StructuredPromptInput["schema"], method?: "jsonMode" | "jsonSchema" | "functionMode"): ChatPromptTemplate<RunInput, any>;
 }
 //#endregion
 export { StructuredPrompt, StructuredPromptInput };

package/dist/prompts/structured.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured.d.cts","names":["ChatPromptValueInterface","RunnableLike","Runnable","RunnableConfig","InputValues","BaseMessagePromptTemplateLike","ChatPromptTemplate","ChatPromptTemplateInput","StructuredPromptInput","RunInput","PartialVariableName","Record","StructuredPrompt","NewRunOutput","Error","Exclude"],"sources":["../../src/prompts/structured.d.ts"],"sourcesContent":["import { ChatPromptValueInterface } from \"../prompt_values.js\";\nimport { RunnableLike, Runnable } from \"../runnables/base.js\";\nimport { RunnableConfig } from \"../runnables/config.js\";\nimport { InputValues } from \"../utils/types/index.js\";\nimport { BaseMessagePromptTemplateLike, ChatPromptTemplate, ChatPromptTemplateInput } from \"./chat.js\";\n/**\n * Interface for the input of a ChatPromptTemplate.\n */\nexport interface StructuredPromptInput<RunInput extends InputValues = any, PartialVariableName extends string = any> extends ChatPromptTemplateInput<RunInput, PartialVariableName> {\n    schema: Record<string, any>;\n    method?: \"jsonMode\" | \"jsonSchema\" | \"functionMode\";\n}\nexport declare class StructuredPrompt<RunInput extends InputValues = any, PartialVariableName extends string = any> extends ChatPromptTemplate<RunInput, PartialVariableName> implements StructuredPromptInput<RunInput, PartialVariableName> {\n    schema: Record<string, any>;\n    method?: \"jsonMode\" | \"jsonSchema\" | \"functionMode\";\n    lc_namespace: string[];\n    get lc_aliases(): Record<string, string>;\n    constructor(input: StructuredPromptInput<RunInput, PartialVariableName>);\n    pipe<NewRunOutput>(coerceable: RunnableLike<ChatPromptValueInterface, NewRunOutput>): Runnable<RunInput, Exclude<NewRunOutput, Error>, RunnableConfig>;\n    static fromMessagesAndSchema<RunInput extends InputValues = any>(promptMessages: (ChatPromptTemplate<InputValues, string> | BaseMessagePromptTemplateLike)[], schema: StructuredPromptInput[\"schema\"], method?: \"jsonMode\" | \"jsonSchema\" | \"functionMode\"): ChatPromptTemplate<RunInput, any>;\n}\n//# sourceMappingURL=structured.d.ts.map"],"mappings":";;;;;;;;;;AAQA;AAAwDI,UAAvCI,qBAAuCJ,CAAAA,iBAAAA,WAAAA,GAAAA,GAAAA,EAAAA,4BAAAA,MAAAA,GAAAA,GAAAA,CAAAA,SAAqEG,uBAArEH,CAA6FK,QAA7FL,EAAuGM,mBAAvGN,CAAAA,CAAAA;EAA6FK,MAAAA,EACzIE,MADyIF,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;EAAUC,MAAAA,CAAAA,EAAAA,UAAAA,GAAAA,YAAAA,GAAAA,cAAAA;;AAAlCH,cAIxGK,gBAJwGL,CAAAA,iBAItEH,WAJsEG,GAAAA,GAAAA,EAAAA,4BAAAA,MAAAA,GAAAA,GAAAA,CAAAA,SAIDD,kBAJCC,CAIkBE,QAJlBF,EAI4BG,mBAJ5BH,CAAAA,YAI4DC,qBAJ5DD,CAIkFE,QAJlFF,EAI4FG,mBAJ5FH,CAAAA,CAAAA;EAAuB,MAAA,EAKxII,MALwI,CAAA,MAAA,EAAA,GAAA,CAAA;EAI/HC,MAAAA,CAAAA,EAAAA,UAAgB,GAAA,YAAAC,GAAAA,cAAAH;EAAkBN,YAAAA,EAAAA,MAAAA,EAAAA;EAAwFK,IAAAA,UAAAA,CAAAA,CAAAA,EAIzHE,MAJyHF,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAUC,WAAAA,CAAAA,KAAAA,EAKlIF,qBALkIE,CAK5GD,QAL4GC,EAKlGA,mBALkGA,CAAAA;EAAsDD,IAAAA,CAAAA,YAAAA,CAAAA,CAAAA,UAAAA,EAM5KR,YAN4KQ,CAM/JT,wBAN+JS,EAMrII,YANqIJ,CAAAA,CAAAA,EAMrHP,QANqHO,CAM5GA,QAN4GA,EAMlGM,OANkGN,CAM1FI,YAN0FJ,EAM5EK,KAN4EL,CAAAA,EAMpEN,cANoEM,CAAAA;EAAUC,OAAAA,qBAAAA,CAAAA,iBAOvKN,WAPuKM,GAAAA,GAAAA,CAAAA,CAAAA,cAAAA,EAAAA,CAOnIJ,kBAPmII,CAOhHN,WAPgHM,EAAAA,MAAAA,CAAAA,GAOzFL,6BAPyFK,CAAAA,EAAAA,EAAAA,MAAAA,EAO/CF,qBAP+CE,CAAAA,QAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA,UAAAA,GAAAA,YAAAA,GAAAA,cAAAA,CAAAA,EAOwCJ,kBAPxCI,CAO2DD,QAP3DC,EAAAA,GAAAA,CAAAA"}

package/dist/prompts/structured.d.ts

@@ -9,31 +9,18 @@ import { BaseMessagePromptTemplateLike, ChatPromptTemplate, ChatPromptTemplateIn
 /**
  * Interface for the input of a ChatPromptTemplate.
  */
-interface StructuredPromptInput<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunInput extends InputValues = any,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-PartialVariableName extends string = any> extends ChatPromptTemplateInput<RunInput, PartialVariableName> {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+interface StructuredPromptInput<RunInput extends InputValues = any, PartialVariableName extends string = any> extends ChatPromptTemplateInput<RunInput, PartialVariableName> {
   schema: Record<string, any>;
   method?: "jsonMode" | "jsonSchema" | "functionMode";
 }
-declare class StructuredPrompt<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunInput extends InputValues = any,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-PartialVariableName extends string = any> extends ChatPromptTemplate<RunInput, PartialVariableName> implements StructuredPromptInput<RunInput, PartialVariableName> {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare class StructuredPrompt<RunInput extends InputValues = any, PartialVariableName extends string = any> extends ChatPromptTemplate<RunInput, PartialVariableName> implements StructuredPromptInput<RunInput, PartialVariableName> {
   schema: Record<string, any>;
   method?: "jsonMode" | "jsonSchema" | "functionMode";
   lc_namespace: string[];
   get lc_aliases(): Record<string, string>;
   constructor(input: StructuredPromptInput<RunInput, PartialVariableName>);
   pipe<NewRunOutput>(coerceable: RunnableLike<ChatPromptValueInterface, NewRunOutput>): Runnable<RunInput, Exclude<NewRunOutput, Error>, RunnableConfig>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  static fromMessagesAndSchema<RunInput extends InputValues = any>(promptMessages: (ChatPromptTemplate<InputValues, string> | BaseMessagePromptTemplateLike)[], schema: StructuredPromptInput["schema"], method?: "jsonMode" | "jsonSchema" | "functionMode"
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  ): ChatPromptTemplate<RunInput, any>;
+  static fromMessagesAndSchema<RunInput extends InputValues = any>(promptMessages: (ChatPromptTemplate<InputValues, string> | BaseMessagePromptTemplateLike)[], schema: StructuredPromptInput["schema"], method?: "jsonMode" | "jsonSchema" | "functionMode"): ChatPromptTemplate<RunInput, any>;
 }
 //#endregion
 export { StructuredPrompt, StructuredPromptInput };

package/dist/prompts/structured.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured.d.ts","names":["ChatPromptValueInterface","RunnableLike","Runnable","RunnableConfig","InputValues","BaseMessagePromptTemplateLike","ChatPromptTemplate","ChatPromptTemplateInput","StructuredPromptInput","RunInput","PartialVariableName","Record","StructuredPrompt","NewRunOutput","Error","Exclude"],"sources":["../../src/prompts/structured.d.ts"],"sourcesContent":["import { ChatPromptValueInterface } from \"../prompt_values.js\";\nimport { RunnableLike, Runnable } from \"../runnables/base.js\";\nimport { RunnableConfig } from \"../runnables/config.js\";\nimport { InputValues } from \"../utils/types/index.js\";\nimport { BaseMessagePromptTemplateLike, ChatPromptTemplate, ChatPromptTemplateInput } from \"./chat.js\";\n/**\n * Interface for the input of a ChatPromptTemplate.\n */\nexport interface StructuredPromptInput<RunInput extends InputValues = any, PartialVariableName extends string = any> extends ChatPromptTemplateInput<RunInput, PartialVariableName> {\n    schema: Record<string, any>;\n    method?: \"jsonMode\" | \"jsonSchema\" | \"functionMode\";\n}\nexport declare class StructuredPrompt<RunInput extends InputValues = any, PartialVariableName extends string = any> extends ChatPromptTemplate<RunInput, PartialVariableName> implements StructuredPromptInput<RunInput, PartialVariableName> {\n    schema: Record<string, any>;\n    method?: \"jsonMode\" | \"jsonSchema\" | \"functionMode\";\n    lc_namespace: string[];\n    get lc_aliases(): Record<string, string>;\n    constructor(input: StructuredPromptInput<RunInput, PartialVariableName>);\n    pipe<NewRunOutput>(coerceable: RunnableLike<ChatPromptValueInterface, NewRunOutput>): Runnable<RunInput, Exclude<NewRunOutput, Error>, RunnableConfig>;\n    static fromMessagesAndSchema<RunInput extends InputValues = any>(promptMessages: (ChatPromptTemplate<InputValues, string> | BaseMessagePromptTemplateLike)[], schema: StructuredPromptInput[\"schema\"], method?: \"jsonMode\" | \"jsonSchema\" | \"functionMode\"): ChatPromptTemplate<RunInput, any>;\n}\n//# sourceMappingURL=structured.d.ts.map"],"mappings":";;;;;;;;;;;AAQiBQ,UAAAA,qBAAqBC,CAAAA,iBAAkBL,WAAlBM,GAAA,GAAA,EAAA,4BAAA,MAAA,GAAA,GAAA,CAAA,SAAuFH,uBAAvF,CAA+GE,QAA/G,EAAyHC,mBAAzH,CAAA,CAAA;EAAkBN,MAAAA,EAC5CO,MAD4CP,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;EAA6FK,MAAAA,CAAAA,EAAAA,UAAAA,GAAAA,YAAAA,GAAAA,cAAAA;;AACzIE,cAGSC,gBAHTD,CAAAA,iBAG2CP,WAH3CO,GAAAA,GAAAA,EAAAA,4BAAAA,MAAAA,GAAAA,GAAAA,CAAAA,SAGgHL,kBAHhHK,CAGmIF,QAHnIE,EAG6ID,mBAH7IC,CAAAA,YAG6KH,qBAH7KG,CAGmMF,QAHnME,EAG6MD,mBAH7MC,CAAAA,CAAAA;EADiHJ,MAAAA,EAKjHI,MALiHJ,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;EAAuB,MAAA,CAAA,EAAA,UAAA,GAAA,YAAA,GAAA,cAAA;EAI/HK,YAAAA,EAAAA,MAAgB,EAAA;EAAkBR,IAAAA,UAAAA,CAAAA,CAAAA,EAIjCO,MAJiCP,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAwFK,WAAAA,CAAAA,KAAAA,EAKxHD,qBALwHC,CAKlGA,QALkGA,EAKxFC,mBALwFD,CAAAA;EAAUC,IAAAA,CAAAA,YAAAA,CAAAA,CAAAA,UAAAA,EAMtHT,YANsHS,CAMzGV,wBANyGU,EAM/EG,YAN+EH,CAAAA,CAAAA,EAM/DR,QAN+DQ,CAMtDD,QANsDC,EAM5CK,OAN4CL,CAMpCG,YANoCH,EAMtBI,KANsBJ,CAAAA,EAMdP,cANcO,CAAAA;EAAsDD,OAAAA,qBAAAA,CAAAA,iBAO7JL,WAP6JK,GAAAA,GAAAA,CAAAA,CAAAA,cAAAA,EAAAA,CAOzHH,kBAPyHG,CAOtGL,WAPsGK,EAAAA,MAAAA,CAAAA,GAO/EJ,6BAP+EI,CAAAA,EAAAA,EAAAA,MAAAA,EAOrCD,qBAPqCC,CAAAA,QAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA,UAAAA,GAAAA,YAAAA,GAAAA,cAAAA,CAAAA,EAOkDH,kBAPlDG,CAOqEA,QAPrEA,EAAAA,GAAAA,CAAAA"}

package/dist/prompts/template.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.cts","names":["MessageContent","InputValues","TemplateFormat","ParsedTemplateNode","ParsedFStringNode","parseFString","parseMustache","interpolateFString","interpolateMustache","Interpolator","Parser","DEFAULT_FORMATTER_MAPPING","Record","DEFAULT_PARSER_MAPPING","renderTemplate","parseTemplate","checkValidTemplate"],"sources":["../../src/prompts/template.d.ts"],"sourcesContent":["import { MessageContent } from \"../messages/index.js\";\nimport type { InputValues } from \"../utils/types/index.js\";\n/**\n * Type that specifies the format of a template.\n */\nexport type TemplateFormat = \"f-string\" | \"mustache\";\n/**\n * Type that represents a node in a parsed format string. It can be either\n * a literal text or a variable name.\n */\nexport type ParsedTemplateNode = {\n    type: \"literal\";\n    text: string;\n} | {\n    type: \"variable\";\n    name: string;\n};\n/**\n * Alias for `ParsedTemplateNode` since it is the same for\n * both f-string and mustache templates.\n */\nexport type ParsedFStringNode = ParsedTemplateNode;\nexport declare const parseFString: (template: string) => ParsedTemplateNode[];\nexport declare const parseMustache: (template: string) => ParsedTemplateNode[];\nexport declare const interpolateFString: (template: string, values: InputValues) => string;\nexport declare const interpolateMustache: (template: string, values: InputValues) => string;\n/**\n * Type that represents a function that takes a template string and a set\n * of input values, and returns a string where all variables in the\n * template have been replaced with their corresponding values.\n */\ntype Interpolator = (template: string, values: InputValues) => string;\n/**\n * Type that represents a function that takes a template string and\n * returns an array of `ParsedTemplateNode`.\n */\ntype Parser = (template: string) => ParsedTemplateNode[];\nexport declare const DEFAULT_FORMATTER_MAPPING: Record<TemplateFormat, Interpolator>;\nexport declare const DEFAULT_PARSER_MAPPING: Record<TemplateFormat, Parser>;\nexport declare const renderTemplate: (template: string, templateFormat: TemplateFormat, inputValues: InputValues) => string;\nexport declare const parseTemplate: (template: string, templateFormat: TemplateFormat) => ParsedTemplateNode[];\nexport declare const checkValidTemplate: (template: MessageContent, templateFormat: TemplateFormat, inputVariables: string[]) => void;\nexport {};\n//# sourceMappingURL=template.d.ts.map"],"mappings":";;;;;;;AAKA;AAKYG,KALAD,cAAAA,GAKkB,UAAA,GAAA,UAAA;AAW9B;AACA;AACA;AACA;AACqBM,KAfTL,kBAAAA,GAe+E;EAMtFM,IAAAA,EAAAA,SAAY;EAKZC,IAAAA,EAAAA,MAAM;AACX,CAAA,GAAqBC;EAAkCT,IAAAA,EAAAA,UAAAA;EAAgBO,IAAAA,EAAAA,MAAAA;CAAvBG;AAAM;AACtD;;;AAA6CA,KAjBjCR,iBAAAA,GAAoBD,kBAiBaS;AAAM,cAhB9BP,YAgB8B,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,GAhBMF,kBAgBN,EAAA;AAC9BW,cAhBAR,aAgBmDJ,EAAAA,CAAAA,QAAAA,EAAAA,MAA6BD,EAAAA,GAhB3CE,kBAgBsD,EAAA;AAC3FY,cAhBAR,kBAgBkDL,EAAAA,CAAAA,QAAmBC,EAAAA,MAAAA,EAAAA,MAAAA,EAhBtBF,WAgBwC,EAAA,GAAA,MAAA;AACvFe,cAhBAR,mBAgB+BR,EAAAA,CAAAA,QAAAA,EAAAA,MAAgCE,EAAAA,MAAAA,EAhBfD,WAgB6B,EAAA,GAAA,MAAA;;;;;;KAV7FQ,YAAAA,8BAA0CR;;;;;KAK1CS,MAAAA,yBAA+BP;cACfQ,2BAA2BC,OAAOV,gBAAgBO;cAClDI,wBAAwBD,OAAOV,gBAAgBQ;cAC/CI,mDAAmDZ,6BAA6BD;cAChFc,kDAAkDb,mBAAmBC;cACrEa,+BAA+BhB,gCAAgCE"}

package/dist/prompts/template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.ts","names":["MessageContent","InputValues","TemplateFormat","ParsedTemplateNode","ParsedFStringNode","parseFString","parseMustache","interpolateFString","interpolateMustache","Interpolator","Parser","DEFAULT_FORMATTER_MAPPING","Record","DEFAULT_PARSER_MAPPING","renderTemplate","parseTemplate","checkValidTemplate"],"sources":["../../src/prompts/template.d.ts"],"sourcesContent":["import { MessageContent } from \"../messages/index.js\";\nimport type { InputValues } from \"../utils/types/index.js\";\n/**\n * Type that specifies the format of a template.\n */\nexport type TemplateFormat = \"f-string\" | \"mustache\";\n/**\n * Type that represents a node in a parsed format string. It can be either\n * a literal text or a variable name.\n */\nexport type ParsedTemplateNode = {\n    type: \"literal\";\n    text: string;\n} | {\n    type: \"variable\";\n    name: string;\n};\n/**\n * Alias for `ParsedTemplateNode` since it is the same for\n * both f-string and mustache templates.\n */\nexport type ParsedFStringNode = ParsedTemplateNode;\nexport declare const parseFString: (template: string) => ParsedTemplateNode[];\nexport declare const parseMustache: (template: string) => ParsedTemplateNode[];\nexport declare const interpolateFString: (template: string, values: InputValues) => string;\nexport declare const interpolateMustache: (template: string, values: InputValues) => string;\n/**\n * Type that represents a function that takes a template string and a set\n * of input values, and returns a string where all variables in the\n * template have been replaced with their corresponding values.\n */\ntype Interpolator = (template: string, values: InputValues) => string;\n/**\n * Type that represents a function that takes a template string and\n * returns an array of `ParsedTemplateNode`.\n */\ntype Parser = (template: string) => ParsedTemplateNode[];\nexport declare const DEFAULT_FORMATTER_MAPPING: Record<TemplateFormat, Interpolator>;\nexport declare const DEFAULT_PARSER_MAPPING: Record<TemplateFormat, Parser>;\nexport declare const renderTemplate: (template: string, templateFormat: TemplateFormat, inputValues: InputValues) => string;\nexport declare const parseTemplate: (template: string, templateFormat: TemplateFormat) => ParsedTemplateNode[];\nexport declare const checkValidTemplate: (template: MessageContent, templateFormat: TemplateFormat, inputVariables: string[]) => void;\nexport {};\n//# sourceMappingURL=template.d.ts.map"],"mappings":";;;;;;;;AAKYE,KAAAA,cAAAA,GAAc,UAAA,GAAA,UAAA;AAK1B;AAWA;AACA;AACA;AACqBK,KAdTJ,kBAAAA,GAc8E;EACrEK,IAAAA,EAAAA,SAAAA;EAMhBC,IAAAA,EAAAA,MAAAA;AAAqD,CAAA,GAKrDC;EACgBC,IAAAA,EAAAA,UAAAA;EAAkCT,IAAAA,EAAAA,MAAAA;CAAgBO;;AAAjB;AACtD;;AAAoEC,KAjBxDN,iBAAAA,GAAoBD,kBAiBoCO;AAAvBE,cAhBxBP,YAgBwBO,EAAAA,CAAAA,QAAAA,EAAAA,MAAAA,EAAAA,GAhBYT,kBAgBZS,EAAAA;AAAM,cAf9BN,aAe8B,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,GAfOH,kBAeP,EAAA;AAC9BW,cAfAP,kBAemDL,EAAAA,CAAAA,QAA6BD,EAAAA,MAAAA,EAAAA,MAAW,EAf5CA,WAe4C,EAAA,GAAA,MAAA;AAC3Fc,cAfAP,mBAekDN,EAAAA,CAAAA,QAAmBC,EAAAA,MAAAA,EAAAA,MAAkB,EAfvCF,WAeuC,EAAA,GAAA,MAAA;AAC5G;;;;;KAVKQ,YAAAA,8BAA0CR;;;;;KAK1CS,MAAAA,yBAA+BP;cACfQ,2BAA2BC,OAAOV,gBAAgBO;cAClDI,wBAAwBD,OAAOV,gBAAgBQ;cAC/CI,mDAAmDZ,6BAA6BD;cAChFc,kDAAkDb,mBAAmBC;cACrEa,+BAA+BhB,gCAAgCE"}

package/dist/retrievers/document_compressors/index.d.cts

@@ -17,7 +17,6 @@ declare abstract class BaseDocumentCompressor {
    * @returns A Promise that resolves with an array of compressed `Document` objects.
    */
   abstract compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   static isBaseDocumentCompressor(x: any): x is BaseDocumentCompressor;
 }
 //#endregion

package/dist/retrievers/document_compressors/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["Callbacks","DocumentInterface","BaseDocumentCompressor","Promise"],"sources":["../../../src/retrievers/document_compressors/index.d.ts"],"sourcesContent":["import { Callbacks } from \"../../callbacks/manager.js\";\nimport { DocumentInterface } from \"../../documents/document.js\";\n/**\n * Base Document Compression class. All compressors should extend this class.\n */\nexport declare abstract class BaseDocumentCompressor {\n    /**\n     * Abstract method that must be implemented by any class that extends\n     * `BaseDocumentCompressor`. This method takes an array of `Document`\n     * objects and a query string as parameters and returns a Promise that\n     * resolves with an array of compressed `Document` objects.\n     * @param documents An array of `Document` objects to be compressed.\n     * @param query A query string.\n     * @returns A Promise that resolves with an array of compressed `Document` objects.\n     */\n    abstract compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;\n    static isBaseDocumentCompressor(x: any): x is BaseDocumentCompressor;\n}\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;AAKA;AAU0CC,uBAVZC,sBAAAA,CAUYD;EAAgDD;;;;AAClB;;;;;wCAD9BC,gDAAgDD,YAAYG,QAAQF;gDAC5DC"}

package/dist/retrievers/document_compressors/index.d.ts

@@ -17,7 +17,6 @@ declare abstract class BaseDocumentCompressor {
    * @returns A Promise that resolves with an array of compressed `Document` objects.
    */
   abstract compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   static isBaseDocumentCompressor(x: any): x is BaseDocumentCompressor;
 }
 //#endregion

package/dist/retrievers/document_compressors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["Callbacks","DocumentInterface","BaseDocumentCompressor","Promise"],"sources":["../../../src/retrievers/document_compressors/index.d.ts"],"sourcesContent":["import { Callbacks } from \"../../callbacks/manager.js\";\nimport { DocumentInterface } from \"../../documents/document.js\";\n/**\n * Base Document Compression class. All compressors should extend this class.\n */\nexport declare abstract class BaseDocumentCompressor {\n    /**\n     * Abstract method that must be implemented by any class that extends\n     * `BaseDocumentCompressor`. This method takes an array of `Document`\n     * objects and a query string as parameters and returns a Promise that\n     * resolves with an array of compressed `Document` objects.\n     * @param documents An array of `Document` objects to be compressed.\n     * @param query A query string.\n     * @returns A Promise that resolves with an array of compressed `Document` objects.\n     */\n    abstract compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;\n    static isBaseDocumentCompressor(x: any): x is BaseDocumentCompressor;\n}\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;AAKA;AAU0CC,uBAVZC,sBAAAA,CAUYD;EAAgDD;;;;AAClB;;;;;wCAD9BC,gDAAgDD,YAAYG,QAAQF;gDAC5DC"}

package/dist/retrievers/index.d.cts

@@ -41,9 +41,7 @@ interface BaseRetrieverInput {
  * @template Metadata - The type of metadata associated with each document,
  *                      defaulting to `Record<string, any>`.
  */
-interface BaseRetrieverInterface<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-Metadata extends Record<string, any> = Record<string, any>> extends RunnableInterface<string, DocumentInterface<Metadata>[]> {}
+interface BaseRetrieverInterface<Metadata extends Record<string, any> = Record<string, any>> extends RunnableInterface<string, DocumentInterface<Metadata>[]> {}
 /**
  * Abstract base class for a document retrieval system, designed to
  * process string queries and return the most relevant documents from a source.
@@ -56,9 +54,7 @@ Metadata extends Record<string, any> = Record<string, any>> extends RunnableInte
  * @template Metadata - The type of metadata associated with each document,
  *                      defaulting to `Record<string, any>`.
  */
-declare abstract class BaseRetriever<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-Metadata extends Record<string, any> = Record<string, any>> extends Runnable<string, DocumentInterface<Metadata>[]> implements BaseRetrieverInterface {
+declare abstract class BaseRetriever<Metadata extends Record<string, any> = Record<string, any>> extends Runnable<string, DocumentInterface<Metadata>[]> implements BaseRetrieverInterface {
   /**
    * Optional callbacks to handle various events in the retrieval process.
    */

package/dist/retrievers/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["CallbackManagerForRetrieverRun","Callbacks","DocumentInterface","Runnable","RunnableInterface","RunnableConfig","BaseRetrieverInput","Record","BaseRetrieverInterface","Metadata","BaseRetriever","Promise"],"sources":["../../src/retrievers/index.d.ts"],"sourcesContent":["import { CallbackManagerForRetrieverRun, Callbacks } from \"../callbacks/manager.js\";\nimport type { DocumentInterface } from \"../documents/document.js\";\nimport { Runnable, type RunnableInterface } from \"../runnables/base.js\";\nimport { RunnableConfig } from \"../runnables/config.js\";\n/**\n * Input configuration options for initializing a retriever that extends\n * the `BaseRetriever` class. This interface provides base properties\n * common to all retrievers, allowing customization of callback functions,\n * tagging, metadata, and logging verbosity.\n *\n * Fields:\n * - `callbacks` (optional): An array of callback functions that handle various\n *   events during retrieval, such as logging, error handling, or progress updates.\n *\n * - `tags` (optional): An array of strings used to add contextual tags to\n *   retrieval operations, allowing for easier categorization and tracking.\n *\n * - `metadata` (optional): A record of key-value pairs to store additional\n *   contextual information for retrieval operations, which can be useful\n *   for logging or auditing purposes.\n *\n * - `verbose` (optional): A boolean flag that, if set to `true`, enables\n *   detailed logging and output during the retrieval process. Defaults to `false`.\n */\nexport interface BaseRetrieverInput {\n    callbacks?: Callbacks;\n    tags?: string[];\n    metadata?: Record<string, unknown>;\n    verbose?: boolean;\n}\n/**\n * Interface for a base retriever that defines core functionality for\n * retrieving relevant documents from a source based on a query.\n *\n * The `BaseRetrieverInterface` standardizes the `getRelevantDocuments` method,\n * enabling retrieval of documents that match the query criteria.\n *\n * @template Metadata - The type of metadata associated with each document,\n *                      defaulting to `Record<string, any>`.\n */\nexport interface BaseRetrieverInterface<Metadata extends Record<string, any> = Record<string, any>> extends RunnableInterface<string, DocumentInterface<Metadata>[]> {\n}\n/**\n * Abstract base class for a document retrieval system, designed to\n * process string queries and return the most relevant documents from a source.\n *\n * `BaseRetriever` provides common properties and methods for derived retrievers,\n * such as callbacks, tagging, and verbose logging. Custom retrieval systems\n * should extend this class and implement `_getRelevantDocuments` to define\n * the specific retrieval logic.\n *\n * @template Metadata - The type of metadata associated with each document,\n *                      defaulting to `Record<string, any>`.\n */\nexport declare abstract class BaseRetriever<Metadata extends Record<string, any> = Record<string, any>> extends Runnable<string, DocumentInterface<Metadata>[]> implements BaseRetrieverInterface {\n    /**\n     * Optional callbacks to handle various events in the retrieval process.\n     */\n    callbacks?: Callbacks;\n    /**\n     * Tags to label or categorize the retrieval operation.\n     */\n    tags?: string[];\n    /**\n     * Metadata to provide additional context or information about the retrieval\n     * operation.\n     */\n    metadata?: Record<string, unknown>;\n    /**\n     * If set to `true`, enables verbose logging for the retrieval process.\n     */\n    verbose?: boolean;\n    /**\n     * Constructs a new `BaseRetriever` instance with optional configuration fields.\n     *\n     * @param fields - Optional input configuration that can include `callbacks`,\n     *                 `tags`, `metadata`, and `verbose` settings for custom retriever behavior.\n     */\n    constructor(fields?: BaseRetrieverInput);\n    /**\n     * TODO: This should be an abstract method, but we'd like to avoid breaking\n     * changes to people currently using subclassed custom retrievers.\n     * Change it on next major release.\n     */\n    /**\n     * Placeholder method for retrieving relevant documents based on a query.\n     *\n     * This method is intended to be implemented by subclasses and will be\n     * converted to an abstract method in the next major release. Currently, it\n     * throws an error if not implemented, ensuring that custom retrievers define\n     * the specific retrieval logic.\n     *\n     * @param _query - The query string used to search for relevant documents.\n     * @param _callbacks - (optional) Callback manager for managing callbacks\n     *                     during retrieval.\n     * @returns A promise resolving to an array of `DocumentInterface` instances relevant to the query.\n     * @throws {Error} Throws an error indicating the method is not implemented.\n     */\n    _getRelevantDocuments(_query: string, _callbacks?: CallbackManagerForRetrieverRun): Promise<DocumentInterface<Metadata>[]>;\n    /**\n     * Executes a retrieval operation.\n     *\n     * @param input - The query string used to search for relevant documents.\n     * @param options - (optional) Configuration options for the retrieval run,\n     *                  which may include callbacks, tags, and metadata.\n     * @returns A promise that resolves to an array of `DocumentInterface` instances\n     *          representing the most relevant documents to the query.\n     */\n    invoke(input: string, options?: RunnableConfig): Promise<DocumentInterface<Metadata>[]>;\n}\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;AAwBA;AAgBA;;;;;;AAA6H;AAc7H;;;;;;;;;;AA4CgGE,UA1E/EI,kBAAAA,CA0E+EJ;EAARS,SAAAA,CAAAA,EAzExEV,SAyEwEU;EAUpDN,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAA2CI,QAAAA,CAAAA,EAjFhEF,MAiFgEE,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;EAAlBP,OAAAA,CAAAA,EAAAA,OAAAA;;;;AAtDoI;;;;;;;;UAdhLM,wCAAwCD,sBAAsBA,6BAA6BH,0BAA0BF,kBAAkBO;;;;;;;;;;;;;uBAc1HC,+BAA+BH,sBAAsBA,6BAA6BJ,iBAAiBD,kBAAkBO,wBAAwBD;;;;cAI3JP;;;;;;;;;aASDM;;;;;;;;;;;uBAWUD;;;;;;;;;;;;;;;;;;;;qDAoB8BN,iCAAiCW,QAAQT,kBAAkBO;;;;;;;;;;kCAU9EJ,iBAAiBM,QAAQT,kBAAkBO"}

package/dist/retrievers/index.d.ts

@@ -42,9 +42,7 @@ interface BaseRetrieverInput {
  * @template Metadata - The type of metadata associated with each document,
  *                      defaulting to `Record<string, any>`.
  */
-interface BaseRetrieverInterface<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-Metadata extends Record<string, any> = Record<string, any>> extends RunnableInterface<string, DocumentInterface<Metadata>[]> {}
+interface BaseRetrieverInterface<Metadata extends Record<string, any> = Record<string, any>> extends RunnableInterface<string, DocumentInterface<Metadata>[]> {}
 /**
  * Abstract base class for a document retrieval system, designed to
  * process string queries and return the most relevant documents from a source.
@@ -57,9 +55,7 @@ Metadata extends Record<string, any> = Record<string, any>> extends RunnableInte
  * @template Metadata - The type of metadata associated with each document,
  *                      defaulting to `Record<string, any>`.
  */
-declare abstract class BaseRetriever<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-Metadata extends Record<string, any> = Record<string, any>> extends Runnable<string, DocumentInterface<Metadata>[]> implements BaseRetrieverInterface {
+declare abstract class BaseRetriever<Metadata extends Record<string, any> = Record<string, any>> extends Runnable<string, DocumentInterface<Metadata>[]> implements BaseRetrieverInterface {
   /**
    * Optional callbacks to handle various events in the retrieval process.
    */

package/dist/retrievers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["CallbackManagerForRetrieverRun","Callbacks","DocumentInterface","Runnable","RunnableInterface","RunnableConfig","BaseRetrieverInput","Record","BaseRetrieverInterface","Metadata","BaseRetriever","Promise"],"sources":["../../src/retrievers/index.d.ts"],"sourcesContent":["import { CallbackManagerForRetrieverRun, Callbacks } from \"../callbacks/manager.js\";\nimport type { DocumentInterface } from \"../documents/document.js\";\nimport { Runnable, type RunnableInterface } from \"../runnables/base.js\";\nimport { RunnableConfig } from \"../runnables/config.js\";\n/**\n * Input configuration options for initializing a retriever that extends\n * the `BaseRetriever` class. This interface provides base properties\n * common to all retrievers, allowing customization of callback functions,\n * tagging, metadata, and logging verbosity.\n *\n * Fields:\n * - `callbacks` (optional): An array of callback functions that handle various\n *   events during retrieval, such as logging, error handling, or progress updates.\n *\n * - `tags` (optional): An array of strings used to add contextual tags to\n *   retrieval operations, allowing for easier categorization and tracking.\n *\n * - `metadata` (optional): A record of key-value pairs to store additional\n *   contextual information for retrieval operations, which can be useful\n *   for logging or auditing purposes.\n *\n * - `verbose` (optional): A boolean flag that, if set to `true`, enables\n *   detailed logging and output during the retrieval process. Defaults to `false`.\n */\nexport interface BaseRetrieverInput {\n    callbacks?: Callbacks;\n    tags?: string[];\n    metadata?: Record<string, unknown>;\n    verbose?: boolean;\n}\n/**\n * Interface for a base retriever that defines core functionality for\n * retrieving relevant documents from a source based on a query.\n *\n * The `BaseRetrieverInterface` standardizes the `getRelevantDocuments` method,\n * enabling retrieval of documents that match the query criteria.\n *\n * @template Metadata - The type of metadata associated with each document,\n *                      defaulting to `Record<string, any>`.\n */\nexport interface BaseRetrieverInterface<Metadata extends Record<string, any> = Record<string, any>> extends RunnableInterface<string, DocumentInterface<Metadata>[]> {\n}\n/**\n * Abstract base class for a document retrieval system, designed to\n * process string queries and return the most relevant documents from a source.\n *\n * `BaseRetriever` provides common properties and methods for derived retrievers,\n * such as callbacks, tagging, and verbose logging. Custom retrieval systems\n * should extend this class and implement `_getRelevantDocuments` to define\n * the specific retrieval logic.\n *\n * @template Metadata - The type of metadata associated with each document,\n *                      defaulting to `Record<string, any>`.\n */\nexport declare abstract class BaseRetriever<Metadata extends Record<string, any> = Record<string, any>> extends Runnable<string, DocumentInterface<Metadata>[]> implements BaseRetrieverInterface {\n    /**\n     * Optional callbacks to handle various events in the retrieval process.\n     */\n    callbacks?: Callbacks;\n    /**\n     * Tags to label or categorize the retrieval operation.\n     */\n    tags?: string[];\n    /**\n     * Metadata to provide additional context or information about the retrieval\n     * operation.\n     */\n    metadata?: Record<string, unknown>;\n    /**\n     * If set to `true`, enables verbose logging for the retrieval process.\n     */\n    verbose?: boolean;\n    /**\n     * Constructs a new `BaseRetriever` instance with optional configuration fields.\n     *\n     * @param fields - Optional input configuration that can include `callbacks`,\n     *                 `tags`, `metadata`, and `verbose` settings for custom retriever behavior.\n     */\n    constructor(fields?: BaseRetrieverInput);\n    /**\n     * TODO: This should be an abstract method, but we'd like to avoid breaking\n     * changes to people currently using subclassed custom retrievers.\n     * Change it on next major release.\n     */\n    /**\n     * Placeholder method for retrieving relevant documents based on a query.\n     *\n     * This method is intended to be implemented by subclasses and will be\n     * converted to an abstract method in the next major release. Currently, it\n     * throws an error if not implemented, ensuring that custom retrievers define\n     * the specific retrieval logic.\n     *\n     * @param _query - The query string used to search for relevant documents.\n     * @param _callbacks - (optional) Callback manager for managing callbacks\n     *                     during retrieval.\n     * @returns A promise resolving to an array of `DocumentInterface` instances relevant to the query.\n     * @throws {Error} Throws an error indicating the method is not implemented.\n     */\n    _getRelevantDocuments(_query: string, _callbacks?: CallbackManagerForRetrieverRun): Promise<DocumentInterface<Metadata>[]>;\n    /**\n     * Executes a retrieval operation.\n     *\n     * @param input - The query string used to search for relevant documents.\n     * @param options - (optional) Configuration options for the retrieval run,\n     *                  which may include callbacks, tags, and metadata.\n     * @returns A promise that resolves to an array of `DocumentInterface` instances\n     *          representing the most relevant documents to the query.\n     */\n    invoke(input: string, options?: RunnableConfig): Promise<DocumentInterface<Metadata>[]>;\n}\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;AAwBA;AAgBA;;;;;;AAA6H;AAc7H;;;;;;;;;AA4CkHS,UA1EjGH,kBAAAA,CA0EiGG;EAAlBP,SAAAA,CAAAA,EAzEhFD,SAyEgFC;EAARS,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAUpDN,QAAAA,CAAAA,EAjFrBE,MAiFqBF,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;EAA2CI,OAAAA,CAAAA,EAAAA,OAAAA;;;;;AAtDkH;;;;;;;UAdhLD,wCAAwCD,sBAAsBA,6BAA6BH,0BAA0BF,kBAAkBO;;;;;;;;;;;;;uBAc1HC,+BAA+BH,sBAAsBA,6BAA6BJ,iBAAiBD,kBAAkBO,wBAAwBD;;;;cAI3JP;;;;;;;;;aASDM;;;;;;;;;;;uBAWUD;;;;;;;;;;;;;;;;;;;;qDAoB8BN,iCAAiCW,QAAQT,kBAAkBO;;;;;;;;;;kCAU9EJ,iBAAiBM,QAAQT,kBAAkBO"}

package/dist/runnables/base.d.cts

@@ -11,33 +11,15 @@ import { Graph } from "./graph.cjs";
 import { TraceableFunction } from "langsmith/singletons/traceable";
 
 //#region src/runnables/base.d.ts
-type RunnableFunc<RunInput, RunOutput, CallOptions extends RunnableConfig = RunnableConfig> = (input: RunInput, options: CallOptions
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-| Record<string, any>
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-| (Record<string, any> & CallOptions)) => RunOutput | Promise<RunOutput>;
+type RunnableFunc<RunInput, RunOutput, CallOptions extends RunnableConfig = RunnableConfig> = (input: RunInput, options: CallOptions | Record<string, any> | (Record<string, any> & CallOptions)) => RunOutput | Promise<RunOutput>;
 type RunnableMapLike<RunInput, RunOutput> = { [K in keyof RunOutput]: RunnableLike<RunInput, RunOutput[K]> };
-type RunnableLike<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunInput = any,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> = RunnableInterface<RunInput, RunOutput, CallOptions> | RunnableFunc<RunInput, RunOutput, CallOptions> | RunnableMapLike<RunInput, RunOutput>;
-type RunnableRetryFailedAttemptHandler = (
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-error: any,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-input: any
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) => any;
+type RunnableLike<RunInput = any, RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> = RunnableInterface<RunInput, RunOutput, CallOptions> | RunnableFunc<RunInput, RunOutput, CallOptions> | RunnableMapLike<RunInput, RunOutput>;
+type RunnableRetryFailedAttemptHandler = (error: any, input: any) => any;
 /**
  * A Runnable is a generic unit of work that can be invoked, batched, streamed, and/or
  * transformed.
  */
-declare abstract class Runnable<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunInput = any,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> extends Serializable implements RunnableInterface<RunInput, RunOutput, CallOptions> {
+declare abstract class Runnable<RunInput = any, RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> extends Serializable implements RunnableInterface<RunInput, RunOutput, CallOptions> {
   protected lc_runnable: boolean;
   name?: string;
   getName(suffix?: string): string;
@@ -281,7 +263,6 @@ RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> extends Se
   }, streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<Uint8Array>;
   private _streamEventsV2;
   private _streamEventsV1;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   static isRunnable(thing: any): thing is Runnable;
   /**
    * Bind lifecycle listeners to a Runnable, returning a new Runnable.
@@ -405,11 +386,7 @@ declare class RunnableBinding<RunInput, RunOutput, CallOptions extends RunnableC
     version: "v1" | "v2";
     encoding: "text/event-stream";
   }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<Uint8Array>;
-  static isRunnableBinding(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  thing: any
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  ): thing is RunnableBinding<any, any, any>;
+  static isRunnableBinding(thing: any): thing is RunnableBinding<any, any, any>;
   /**
    * Bind lifecycle listeners to a Runnable, returning a new Runnable.
    * The Run object contains information about the run, including its id,
@@ -539,11 +516,7 @@ declare class RunnableEach<RunInputItem, RunOutputItem, CallOptions extends Runn
  *   });
  * ```
  */
-declare class RunnableRetry<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunInput = any,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> extends RunnableBinding<RunInput, RunOutput, CallOptions> {
+declare class RunnableRetry<RunInput = any, RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> extends RunnableBinding<RunInput, RunOutput, CallOptions> {
   static lc_name(): string;
   lc_namespace: string[];
   protected maxAttemptNumber: number;
@@ -577,7 +550,6 @@ RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> extends Ru
 type RunnableSequenceFields<RunInput, RunOutput> = {
   first: Runnable<RunInput>;
   middle?: Runnable[];
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   last: Runnable<any, RunOutput>;
   name?: string;
   omitSequenceTags?: boolean;
@@ -593,15 +565,10 @@ type RunnableSequenceFields<RunInput, RunOutput> = {
  * const result = await chain.invoke({ topic: "bears" });
  * ```
  */
-declare class RunnableSequence<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunInput = any,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunOutput = any> extends Runnable<RunInput, RunOutput> {
+declare class RunnableSequence<RunInput = any, RunOutput = any> extends Runnable<RunInput, RunOutput> {
   static lc_name(): string;
   protected first: Runnable<RunInput>;
   protected middle: Runnable[];
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   protected last: Runnable<any, RunOutput>;
   omitSequenceTags: boolean;
   lc_serializable: boolean;
@@ -621,12 +588,8 @@ RunOutput = any> extends Runnable<RunInput, RunOutput> {
   _streamIterator(input: RunInput, options?: RunnableConfig): AsyncGenerator<RunOutput>;
   getGraph(config?: RunnableConfig): Graph;
   pipe<NewRunOutput>(coerceable: RunnableLike<RunOutput, NewRunOutput>): RunnableSequence<RunInput, Exclude<NewRunOutput, Error>>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   static isRunnableSequence(thing: any): thing is RunnableSequence;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  static from<RunInput = any, RunOutput = any>([first, ...runnables]: [RunnableLike<RunInput>, ...RunnableLike[],
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  RunnableLike<any, RunOutput>], nameOrFields?: string | Omit<RunnableSequenceFields<RunInput, RunOutput>, "first" | "middle" | "last">): RunnableSequence<RunInput, Exclude<RunOutput, Error>>;
+  static from<RunInput = any, RunOutput = any>([first, ...runnables]: [RunnableLike<RunInput>, ...RunnableLike[], RunnableLike<any, RunOutput>], nameOrFields?: string | Omit<RunnableSequenceFields<RunInput, RunOutput>, "first" | "middle" | "last">): RunnableSequence<RunInput, Exclude<RunOutput, Error>>;
 }
 /**
  * A runnable that runs a mapping of runnables in parallel,
@@ -644,11 +607,7 @@ RunOutput = any> extends Runnable<RunInput, RunOutput> {
  * const result = await mapChain.invoke({ topic: "bear" });
  * ```
  */
-declare class RunnableMap<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunInput = any,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunOutput extends Record<string, any> = Record<string, any>> extends Runnable<RunInput, RunOutput> {
+declare class RunnableMap<RunInput = any, RunOutput extends Record<string, any> = Record<string, any>> extends Runnable<RunInput, RunOutput> {
   static lc_name(): string;
   lc_namespace: string[];
   lc_serializable: boolean;
@@ -657,9 +616,7 @@ RunOutput extends Record<string, any> = Record<string, any>> extends Runnable<Ru
   constructor(fields: {
     steps: RunnableMapLike<RunInput, RunOutput>;
   });
-  static from<RunInput,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  RunOutput extends Record<string, any> = Record<string, any>>(steps: RunnableMapLike<RunInput, RunOutput>): RunnableMap<RunInput, RunOutput>;
+  static from<RunInput, RunOutput extends Record<string, any> = Record<string, any>>(steps: RunnableMapLike<RunInput, RunOutput>): RunnableMap<RunInput, RunOutput>;
   invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunOutput>;
   _transform(generator: AsyncGenerator<RunInput>, runManager?: CallbackManagerForChainRun, options?: Partial<RunnableConfig>): AsyncGenerator<RunOutput>;
   transform(generator: AsyncGenerator<RunInput>, options?: Partial<RunnableConfig>): AsyncGenerator<RunOutput>;
@@ -829,7 +786,6 @@ declare class RunnableWithFallbacks<RunInput, RunOutput> extends Runnable<RunInp
   }): Promise<(RunOutput | Error)[]>;
   batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
 }
-// TODO: Figure out why the compiler needs help eliminating Error as a RunOutput type
 declare function _coerceToRunnable<RunInput, RunOutput, CallOptions extends RunnableConfig = RunnableConfig>(coerceable: RunnableLike<RunInput, RunOutput, CallOptions>): Runnable<RunInput, Exclude<RunOutput, Error>, CallOptions>;
 interface RunnableAssignFields<RunInput> {
   mapper: RunnableMap<RunInput>;
@@ -865,11 +821,7 @@ interface RunnableAssignFields<RunInput> {
  * // { name: "Alice", birthYear: 1990, age_step: { age: 34 }, greeting_step: { greeting: "Hello, Alice!" } }
  * ```
  */
-declare class RunnableAssign<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunInput extends Record<string, any> = Record<string, any>,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunOutput extends Record<string, any> = Record<string, any>, CallOptions extends RunnableConfig = RunnableConfig> extends Runnable<RunInput, RunOutput> implements RunnableAssignFields<RunInput> {
+declare class RunnableAssign<RunInput extends Record<string, any> = Record<string, any>, RunOutput extends Record<string, any> = Record<string, any>, CallOptions extends RunnableConfig = RunnableConfig> extends Runnable<RunInput, RunOutput> implements RunnableAssignFields<RunInput> {
   static lc_name(): string;
   lc_namespace: string[];
   lc_serializable: boolean;
@@ -907,11 +859,7 @@ interface RunnablePickFields {
  * // { name: 'John', city: 'New York' }
  * ```
  */
-declare class RunnablePick<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunInput extends Record<string, any> = Record<string, any>,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunOutput extends Record<string, any> | any = Record<string, any> | any, CallOptions extends RunnableConfig = RunnableConfig> extends Runnable<RunInput, RunOutput> implements RunnablePickFields {
+declare class RunnablePick<RunInput extends Record<string, any> = Record<string, any>, RunOutput extends Record<string, any> | any = Record<string, any> | any, CallOptions extends RunnableConfig = RunnableConfig> extends Runnable<RunInput, RunOutput> implements RunnablePickFields {
   static lc_name(): string;
   lc_namespace: string[];
   lc_serializable: boolean;