@langchain/core 1.0.6 → 1.1.1

package/dist/example_selectors/conditional.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"conditional.d.ts","names":["BaseChatModel","BasePromptTemplate","BaseLanguageModelInterface","BaseLLM","PartialValues","BaseGetPromptAsyncOptions","BasePromptSelector","Promise","ConditionalPromptSelector","Array","isLLM","isChatModel"],"sources":["../../src/example_selectors/conditional.d.ts"],"sourcesContent":["import type { BaseChatModel } from \"../language_models/chat_models.js\";\nimport type { BasePromptTemplate } from \"../prompts/base.js\";\nimport type { BaseLanguageModelInterface } from \"../language_models/base.js\";\nimport type { BaseLLM } from \"../language_models/llms.js\";\nimport type { PartialValues } from \"../utils/types/index.js\";\nexport type BaseGetPromptAsyncOptions = {\n    partialVariables?: PartialValues;\n};\n/**\n * Abstract class that defines the interface for selecting a prompt for a\n * given language model.\n */\nexport declare abstract class BasePromptSelector {\n    /**\n     * Abstract method that must be implemented by any class that extends\n     * `BasePromptSelector`. It takes a language model as an argument and\n     * returns a prompt template.\n     * @param llm The language model for which to get a prompt.\n     * @returns A prompt template.\n     */\n    abstract getPrompt(llm: BaseLanguageModelInterface): BasePromptTemplate;\n    /**\n     * Asynchronous version of `getPrompt` that also accepts an options object\n     * for partial variables.\n     * @param llm The language model for which to get a prompt.\n     * @param options Optional object for partial variables.\n     * @returns A Promise that resolves to a prompt template.\n     */\n    getPromptAsync(llm: BaseLanguageModelInterface, options?: BaseGetPromptAsyncOptions): Promise<BasePromptTemplate>;\n}\n/**\n * Concrete implementation of `BasePromptSelector` that selects a prompt\n * based on a set of conditions. It has a default prompt that it returns\n * if none of the conditions are met.\n */\nexport declare class ConditionalPromptSelector extends BasePromptSelector {\n    defaultPrompt: BasePromptTemplate;\n    conditionals: Array<[\n        condition: (llm: BaseLanguageModelInterface) => boolean,\n        prompt: BasePromptTemplate\n    ]>;\n    constructor(default_prompt: BasePromptTemplate, conditionals?: Array<[\n        condition: (llm: BaseLanguageModelInterface) => boolean,\n        prompt: BasePromptTemplate\n    ]>);\n    /**\n     * Method that selects a prompt based on a set of conditions. If none of\n     * the conditions are met, it returns the default prompt.\n     * @param llm The language model for which to get a prompt.\n     * @returns A prompt template.\n     */\n    getPrompt(llm: BaseLanguageModelInterface): BasePromptTemplate;\n}\n/**\n * Type guard function that checks if a given language model is of type\n * `BaseLLM`.\n */\nexport declare function isLLM(llm: BaseLanguageModelInterface): llm is BaseLLM;\n/**\n * Type guard function that checks if a given language model is of type\n * `BaseChatModel`.\n */\nexport declare function isChatModel(llm: BaseLanguageModelInterface): llm is BaseChatModel;\n"],"mappings":";;;;;;;KAKYK,yBAAAA;qBACWD;AADvB,CAAA;AAOA;;;;AAgBwBF,uBAhBMI,kBAAAA,CAgBNJ;EAA0B;;;AAA+C;AAOjG;;;EACqC,SAEZA,SAAAA,CAAAA,GAAAA,EAlBGA,0BAkBHA,CAAAA,EAlBgCD,kBAkBhCC;EAA0B;;;;;;;EAaN,cAAGD,CAAAA,GAAAA,EAvBxBC,0BAuBwBD,EAAAA,OAAAA,CAAAA,EAvBcI,yBAuBdJ,CAAAA,EAvB0CM,OAuB1CN,CAvBkDA,kBAuBlDA,CAAAA;;AAhByB;AAsBzE;;;;AAA8E,cAtBzDO,yBAAAA,SAAkCF,kBAAAA,CAsBuB;EAKtDK,aAAAA,EA1BLV,kBA0BgB;EAAA,YAAA,EAzBjBQ,KAyBiB,CAAA,CAAMP,SAAAA,EAAAA,CAAAA,GAAAA,EAxBhBA,0BAwBgBA,EAAAA,GAAAA,OAAAA,EAAoCF,MAAAA,EAvB7DC,kBAuB6DD,CAAa,CAAA;8BArB1DC,mCAAmCQ,wBAC1CP,gDACTD;;;;;;;iBAQGC,6BAA6BD;;;;;;iBAMxBS,KAAAA,MAAWR,oCAAoCC;;;;;iBAK/CQ,WAAAA,MAAiBT,oCAAoCF"}

package/dist/example_selectors/length_based.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"length_based.d.cts","names":["Example","BaseExampleSelector","PromptTemplate","LengthBasedExampleSelectorInput","LengthBasedExampleSelector","Promise"],"sources":["../../src/example_selectors/length_based.d.ts"],"sourcesContent":["import { Example } from \"../prompts/base.js\";\nimport { BaseExampleSelector } from \"./base.js\";\nimport { PromptTemplate } from \"../prompts/prompt.js\";\n/**\n * Interface for the input parameters of the LengthBasedExampleSelector\n * class.\n */\nexport interface LengthBasedExampleSelectorInput {\n    examplePrompt: PromptTemplate;\n    maxLength?: number;\n    getTextLength?: (text: string) => number;\n}\n/**\n * A specialized example selector that selects examples based on their\n * length, ensuring that the total length of the selected examples does\n * not exceed a specified maximum length.\n * @example\n * ```typescript\n * const exampleSelector = new LengthBasedExampleSelector(\n *   [\n *     { input: \"happy\", output: \"sad\" },\n *     { input: \"tall\", output: \"short\" },\n *     { input: \"energetic\", output: \"lethargic\" },\n *     { input: \"sunny\", output: \"gloomy\" },\n *     { input: \"windy\", output: \"calm\" },\n *   ],\n *   {\n *     examplePrompt: new PromptTemplate({\n *       inputVariables: [\"input\", \"output\"],\n *       template: \"Input: {input}\\nOutput: {output}\",\n *     }),\n *     maxLength: 25,\n *   },\n * );\n * const dynamicPrompt = new FewShotPromptTemplate({\n *   exampleSelector,\n *   examplePrompt: new PromptTemplate({\n *     inputVariables: [\"input\", \"output\"],\n *     template: \"Input: {input}\\nOutput: {output}\",\n *   }),\n *   prefix: \"Give the antonym of every input\",\n *   suffix: \"Input: {adjective}\\nOutput:\",\n *   inputVariables: [\"adjective\"],\n * });\n * console.log(dynamicPrompt.format({ adjective: \"big\" }));\n * console.log(\n *   dynamicPrompt.format({\n *     adjective:\n *       \"big and huge and massive and large and gigantic and tall and much much much much much bigger than everything else\",\n *   }),\n * );\n * ```\n */\nexport declare class LengthBasedExampleSelector extends BaseExampleSelector {\n    protected examples: Example[];\n    examplePrompt!: PromptTemplate;\n    getTextLength: (text: string) => number;\n    maxLength: number;\n    exampleTextLengths: number[];\n    constructor(data: LengthBasedExampleSelectorInput);\n    /**\n     * Adds an example to the list of examples and calculates its length.\n     * @param example The example to be added.\n     * @returns Promise that resolves when the example has been added and its length calculated.\n     */\n    addExample(example: Example): Promise<void>;\n    /**\n     * Calculates the lengths of the examples.\n     * @param v Array of lengths of the examples.\n     * @param values Instance of LengthBasedExampleSelector.\n     * @returns Promise that resolves with an array of lengths of the examples.\n     */\n    calculateExampleTextLengths(v: number[], values: LengthBasedExampleSelector): Promise<number[]>;\n    /**\n     * Selects examples until the total length of the selected examples\n     * reaches the maxLength.\n     * @param inputVariables The input variables for the examples.\n     * @returns Promise that resolves with an array of selected examples.\n     */\n    selectExamples(inputVariables: Example): Promise<Example[]>;\n    /**\n     * Creates a new instance of LengthBasedExampleSelector and adds a list of\n     * examples to it.\n     * @param examples Array of examples to be added.\n     * @param args Input parameters for the LengthBasedExampleSelector.\n     * @returns Promise that resolves with a new instance of LengthBasedExampleSelector with the examples added.\n     */\n    static fromExamples(examples: Example[], args: LengthBasedExampleSelectorInput): Promise<LengthBasedExampleSelector>;\n}\n"],"mappings":";;;;;;;;AAOA;AA8CA;AAA+C,UA9C9BG,+BAAAA,CA8C8B;EAAA,aACvBH,EA9CLE,cA8CKF;EAAO,SACXE,CAAAA,EAAAA,MAAAA;EAAc,aAIZC,CAAAA,EAAAA,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,GAAAA,MAAAA;;;;;;;;;;;;;AANqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAtDC,0BAAAA,SAAmCH,mBAAAA;sBAChCD;kBACJE;;;;oBAIEC;;;;;;sBAMEH,UAAUK;;;;;;;mDAOmBD,6BAA6BC;;;;;;;iCAO/CL,UAAUK,QAAQL;;;;;;;;gCAQnBA,iBAAiBG,kCAAkCE,QAAQD"}

package/dist/example_selectors/length_based.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"length_based.d.ts","names":["Example","BaseExampleSelector","PromptTemplate","LengthBasedExampleSelectorInput","LengthBasedExampleSelector","Promise"],"sources":["../../src/example_selectors/length_based.d.ts"],"sourcesContent":["import { Example } from \"../prompts/base.js\";\nimport { BaseExampleSelector } from \"./base.js\";\nimport { PromptTemplate } from \"../prompts/prompt.js\";\n/**\n * Interface for the input parameters of the LengthBasedExampleSelector\n * class.\n */\nexport interface LengthBasedExampleSelectorInput {\n    examplePrompt: PromptTemplate;\n    maxLength?: number;\n    getTextLength?: (text: string) => number;\n}\n/**\n * A specialized example selector that selects examples based on their\n * length, ensuring that the total length of the selected examples does\n * not exceed a specified maximum length.\n * @example\n * ```typescript\n * const exampleSelector = new LengthBasedExampleSelector(\n *   [\n *     { input: \"happy\", output: \"sad\" },\n *     { input: \"tall\", output: \"short\" },\n *     { input: \"energetic\", output: \"lethargic\" },\n *     { input: \"sunny\", output: \"gloomy\" },\n *     { input: \"windy\", output: \"calm\" },\n *   ],\n *   {\n *     examplePrompt: new PromptTemplate({\n *       inputVariables: [\"input\", \"output\"],\n *       template: \"Input: {input}\\nOutput: {output}\",\n *     }),\n *     maxLength: 25,\n *   },\n * );\n * const dynamicPrompt = new FewShotPromptTemplate({\n *   exampleSelector,\n *   examplePrompt: new PromptTemplate({\n *     inputVariables: [\"input\", \"output\"],\n *     template: \"Input: {input}\\nOutput: {output}\",\n *   }),\n *   prefix: \"Give the antonym of every input\",\n *   suffix: \"Input: {adjective}\\nOutput:\",\n *   inputVariables: [\"adjective\"],\n * });\n * console.log(dynamicPrompt.format({ adjective: \"big\" }));\n * console.log(\n *   dynamicPrompt.format({\n *     adjective:\n *       \"big and huge and massive and large and gigantic and tall and much much much much much bigger than everything else\",\n *   }),\n * );\n * ```\n */\nexport declare class LengthBasedExampleSelector extends BaseExampleSelector {\n    protected examples: Example[];\n    examplePrompt!: PromptTemplate;\n    getTextLength: (text: string) => number;\n    maxLength: number;\n    exampleTextLengths: number[];\n    constructor(data: LengthBasedExampleSelectorInput);\n    /**\n     * Adds an example to the list of examples and calculates its length.\n     * @param example The example to be added.\n     * @returns Promise that resolves when the example has been added and its length calculated.\n     */\n    addExample(example: Example): Promise<void>;\n    /**\n     * Calculates the lengths of the examples.\n     * @param v Array of lengths of the examples.\n     * @param values Instance of LengthBasedExampleSelector.\n     * @returns Promise that resolves with an array of lengths of the examples.\n     */\n    calculateExampleTextLengths(v: number[], values: LengthBasedExampleSelector): Promise<number[]>;\n    /**\n     * Selects examples until the total length of the selected examples\n     * reaches the maxLength.\n     * @param inputVariables The input variables for the examples.\n     * @returns Promise that resolves with an array of selected examples.\n     */\n    selectExamples(inputVariables: Example): Promise<Example[]>;\n    /**\n     * Creates a new instance of LengthBasedExampleSelector and adds a list of\n     * examples to it.\n     * @param examples Array of examples to be added.\n     * @param args Input parameters for the LengthBasedExampleSelector.\n     * @returns Promise that resolves with a new instance of LengthBasedExampleSelector with the examples added.\n     */\n    static fromExamples(examples: Example[], args: LengthBasedExampleSelectorInput): Promise<LengthBasedExampleSelector>;\n}\n"],"mappings":";;;;;;;;AAOA;AA8CA;AAA+C,UA9C9BG,+BAAAA,CA8C8B;EAAA,aACvBH,EA9CLE,cA8CKF;EAAO,SACXE,CAAAA,EAAAA,MAAAA;EAAc,aAIZC,CAAAA,EAAAA,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,GAAAA,MAAAA;;;;;;;;;;;;;AANqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAtDC,0BAAAA,SAAmCH,mBAAAA;sBAChCD;kBACJE;;;;oBAIEC;;;;;;sBAMEH,UAAUK;;;;;;;mDAOmBD,6BAA6BC;;;;;;;iCAO/CL,UAAUK,QAAQL;;;;;;;;gCAQnBA,iBAAiBG,kCAAkCE,QAAQD"}

package/dist/example_selectors/semantic_similarity.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"semantic_similarity.d.cts","names":["Embeddings","VectorStoreInterface","VectorStoreRetrieverInterface","VectorStore","Example","BaseExampleSelector","SemanticSimilarityExampleSelectorInput","V","SemanticSimilarityExampleSelector","Promise","T","Record","C","Parameters"],"sources":["../../src/example_selectors/semantic_similarity.d.ts"],"sourcesContent":["import type { Embeddings } from \"../embeddings.js\";\nimport type { VectorStoreInterface, VectorStoreRetrieverInterface, VectorStore } from \"../vectorstores.js\";\nimport type { Example } from \"../prompts/base.js\";\nimport { BaseExampleSelector } from \"./base.js\";\n/**\n * Interface for the input data of the SemanticSimilarityExampleSelector\n * class.\n */\nexport type SemanticSimilarityExampleSelectorInput<V extends VectorStoreInterface = VectorStoreInterface> = {\n    vectorStore: V;\n    k?: number;\n    filter?: V[\"FilterType\"];\n    exampleKeys?: string[];\n    inputKeys?: string[];\n    vectorStoreRetriever?: never;\n} | {\n    vectorStoreRetriever: VectorStoreRetrieverInterface<V>;\n    exampleKeys?: string[];\n    inputKeys?: string[];\n    vectorStore?: never;\n    k?: never;\n    filter?: never;\n};\n/**\n * Class that selects examples based on semantic similarity. It extends\n * the BaseExampleSelector class.\n * @example\n * ```typescript\n * const exampleSelector = await SemanticSimilarityExampleSelector.fromExamples(\n *   [\n *     { input: \"happy\", output: \"sad\" },\n *     { input: \"tall\", output: \"short\" },\n *     { input: \"energetic\", output: \"lethargic\" },\n *     { input: \"sunny\", output: \"gloomy\" },\n *     { input: \"windy\", output: \"calm\" },\n *   ],\n *   new OpenAIEmbeddings(),\n *   HNSWLib,\n *   { k: 1 },\n * );\n * const dynamicPrompt = new FewShotPromptTemplate({\n *   exampleSelector,\n *   examplePrompt: PromptTemplate.fromTemplate(\n *     \"Input: {input}\\nOutput: {output}\",\n *   ),\n *   prefix: \"Give the antonym of every input\",\n *   suffix: \"Input: {adjective}\\nOutput:\",\n *   inputVariables: [\"adjective\"],\n * });\n * console.log(await dynamicPrompt.format({ adjective: \"rainy\" }));\n * ```\n */\nexport declare class SemanticSimilarityExampleSelector<V extends VectorStoreInterface = VectorStoreInterface> extends BaseExampleSelector {\n    vectorStoreRetriever: VectorStoreRetrieverInterface<V>;\n    exampleKeys?: string[];\n    inputKeys?: string[];\n    constructor(data: SemanticSimilarityExampleSelectorInput<V>);\n    /**\n     * Method that adds a new example to the vectorStore. The example is\n     * converted to a string and added to the vectorStore as a document.\n     * @param example The example to be added to the vectorStore.\n     * @returns Promise that resolves when the example has been added to the vectorStore.\n     */\n    addExample(example: Example): Promise<void>;\n    /**\n     * Method that selects which examples to use based on semantic similarity.\n     * It performs a similarity search in the vectorStore using the input\n     * variables and returns the examples with the highest similarity.\n     * @param inputVariables The input variables used for the similarity search.\n     * @returns Promise that resolves with an array of the selected examples.\n     */\n    selectExamples<T>(inputVariables: Record<string, T>): Promise<Example[]>;\n    /**\n     * Static method that creates a new instance of\n     * SemanticSimilarityExampleSelector. It takes a list of examples, an\n     * instance of Embeddings, a VectorStore class, and an options object as\n     * parameters. It converts the examples to strings, creates a VectorStore\n     * from the strings and the embeddings, and returns a new\n     * SemanticSimilarityExampleSelector with the created VectorStore and the\n     * options provided.\n     * @param examples The list of examples to be used.\n     * @param embeddings The instance of Embeddings to be used.\n     * @param vectorStoreCls The VectorStore class to be used.\n     * @param options The options object for the SemanticSimilarityExampleSelector.\n     * @returns Promise that resolves with a new instance of SemanticSimilarityExampleSelector.\n     */\n    static fromExamples<C extends typeof VectorStore>(examples: Record<string, string>[], embeddings: Embeddings, vectorStoreCls: C, options?: {\n        k?: number;\n        inputKeys?: string[];\n    } & Parameters<C[\"fromTexts\"]>[3]): Promise<SemanticSimilarityExampleSelector>;\n}\n"],"mappings":";;;;;;;;;AAQA;;AAA6DC,KAAjDK,sCAAiDL,CAAAA,UAAAA,oBAAAA,GAAuBA,oBAAvBA,CAAAA,GAAAA;EAAoB,WAAGA,EACnEM,CADmEN;EAAoB,CAAA,CAAA,EACvFM,MAAAA;EAAC,MAELA,CAAAA,EAAAA,CAAAA,CAAAA,YAAAA,CAAAA;EAAC,WAK0CA,CAAAA,EAAAA,MAAAA,EAAAA;EAAC,SAA/BL,CAAAA,EAAAA,MAAAA,EAAAA;EAA6B,oBAAA,CAAA,EAAA,KAAA;AAoCvD,CAAA,GAAqBM;EAAiC,oBAAA,EApC5BN,6BAoC4B,CApCEK,CAoCF,CAAA;EAAA,WAAWN,CAAAA,EAAAA,MAAAA,EAAAA;EAAoB,SAAGA,CAAAA,EAAAA,MAAAA,EAAAA;EAAoB,WACpDM,CAAAA,EAAAA,KAAAA;EAAC,CAAA,CAAA,EAA/BL,KAAAA;EAA6B,MAGMK,CAAAA,EAAAA,KAAAA;CAAC;;;;;;;;;;;;;;;;AAJ2E;;;;;;;;;;;;;;cAApHC,4CAA4CP,uBAAuBA,8BAA8BI,mBAAAA;wBAC5FH,8BAA8BK;;;oBAGlCD,uCAAuCC;;;;;;;sBAOrCH,UAAUK;;;;;;;;oCAQIE,eAAeD,KAAKD,QAAQL;;;;;;;;;;;;;;;uCAezBD,uBAAuBQ,sCAAsCX,4BAA4BY;;;MAG1HC,WAAWD,qBAAqBH,QAAQD"}

package/dist/example_selectors/semantic_similarity.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"semantic_similarity.d.ts","names":["Embeddings","VectorStoreInterface","VectorStoreRetrieverInterface","VectorStore","Example","BaseExampleSelector","SemanticSimilarityExampleSelectorInput","V","SemanticSimilarityExampleSelector","Promise","T","Record","C","Parameters"],"sources":["../../src/example_selectors/semantic_similarity.d.ts"],"sourcesContent":["import type { Embeddings } from \"../embeddings.js\";\nimport type { VectorStoreInterface, VectorStoreRetrieverInterface, VectorStore } from \"../vectorstores.js\";\nimport type { Example } from \"../prompts/base.js\";\nimport { BaseExampleSelector } from \"./base.js\";\n/**\n * Interface for the input data of the SemanticSimilarityExampleSelector\n * class.\n */\nexport type SemanticSimilarityExampleSelectorInput<V extends VectorStoreInterface = VectorStoreInterface> = {\n    vectorStore: V;\n    k?: number;\n    filter?: V[\"FilterType\"];\n    exampleKeys?: string[];\n    inputKeys?: string[];\n    vectorStoreRetriever?: never;\n} | {\n    vectorStoreRetriever: VectorStoreRetrieverInterface<V>;\n    exampleKeys?: string[];\n    inputKeys?: string[];\n    vectorStore?: never;\n    k?: never;\n    filter?: never;\n};\n/**\n * Class that selects examples based on semantic similarity. It extends\n * the BaseExampleSelector class.\n * @example\n * ```typescript\n * const exampleSelector = await SemanticSimilarityExampleSelector.fromExamples(\n *   [\n *     { input: \"happy\", output: \"sad\" },\n *     { input: \"tall\", output: \"short\" },\n *     { input: \"energetic\", output: \"lethargic\" },\n *     { input: \"sunny\", output: \"gloomy\" },\n *     { input: \"windy\", output: \"calm\" },\n *   ],\n *   new OpenAIEmbeddings(),\n *   HNSWLib,\n *   { k: 1 },\n * );\n * const dynamicPrompt = new FewShotPromptTemplate({\n *   exampleSelector,\n *   examplePrompt: PromptTemplate.fromTemplate(\n *     \"Input: {input}\\nOutput: {output}\",\n *   ),\n *   prefix: \"Give the antonym of every input\",\n *   suffix: \"Input: {adjective}\\nOutput:\",\n *   inputVariables: [\"adjective\"],\n * });\n * console.log(await dynamicPrompt.format({ adjective: \"rainy\" }));\n * ```\n */\nexport declare class SemanticSimilarityExampleSelector<V extends VectorStoreInterface = VectorStoreInterface> extends BaseExampleSelector {\n    vectorStoreRetriever: VectorStoreRetrieverInterface<V>;\n    exampleKeys?: string[];\n    inputKeys?: string[];\n    constructor(data: SemanticSimilarityExampleSelectorInput<V>);\n    /**\n     * Method that adds a new example to the vectorStore. The example is\n     * converted to a string and added to the vectorStore as a document.\n     * @param example The example to be added to the vectorStore.\n     * @returns Promise that resolves when the example has been added to the vectorStore.\n     */\n    addExample(example: Example): Promise<void>;\n    /**\n     * Method that selects which examples to use based on semantic similarity.\n     * It performs a similarity search in the vectorStore using the input\n     * variables and returns the examples with the highest similarity.\n     * @param inputVariables The input variables used for the similarity search.\n     * @returns Promise that resolves with an array of the selected examples.\n     */\n    selectExamples<T>(inputVariables: Record<string, T>): Promise<Example[]>;\n    /**\n     * Static method that creates a new instance of\n     * SemanticSimilarityExampleSelector. It takes a list of examples, an\n     * instance of Embeddings, a VectorStore class, and an options object as\n     * parameters. It converts the examples to strings, creates a VectorStore\n     * from the strings and the embeddings, and returns a new\n     * SemanticSimilarityExampleSelector with the created VectorStore and the\n     * options provided.\n     * @param examples The list of examples to be used.\n     * @param embeddings The instance of Embeddings to be used.\n     * @param vectorStoreCls The VectorStore class to be used.\n     * @param options The options object for the SemanticSimilarityExampleSelector.\n     * @returns Promise that resolves with a new instance of SemanticSimilarityExampleSelector.\n     */\n    static fromExamples<C extends typeof VectorStore>(examples: Record<string, string>[], embeddings: Embeddings, vectorStoreCls: C, options?: {\n        k?: number;\n        inputKeys?: string[];\n    } & Parameters<C[\"fromTexts\"]>[3]): Promise<SemanticSimilarityExampleSelector>;\n}\n"],"mappings":";;;;;;;;;AAQA;;AAA6DC,KAAjDK,sCAAiDL,CAAAA,UAAAA,oBAAAA,GAAuBA,oBAAvBA,CAAAA,GAAAA;EAAoB,WAAGA,EACnEM,CADmEN;EAAoB,CAAA,CAAA,EACvFM,MAAAA;EAAC,MAELA,CAAAA,EAAAA,CAAAA,CAAAA,YAAAA,CAAAA;EAAC,WAK0CA,CAAAA,EAAAA,MAAAA,EAAAA;EAAC,SAA/BL,CAAAA,EAAAA,MAAAA,EAAAA;EAA6B,oBAAA,CAAA,EAAA,KAAA;AAoCvD,CAAA,GAAqBM;EAAiC,oBAAA,EApC5BN,6BAoC4B,CApCEK,CAoCF,CAAA;EAAA,WAAWN,CAAAA,EAAAA,MAAAA,EAAAA;EAAoB,SAAGA,CAAAA,EAAAA,MAAAA,EAAAA;EAAoB,WACpDM,CAAAA,EAAAA,KAAAA;EAAC,CAAA,CAAA,EAA/BL,KAAAA;EAA6B,MAGMK,CAAAA,EAAAA,KAAAA;CAAC;;;;;;;;;;;;;;;;AAJ2E;;;;;;;;;;;;;;cAApHC,4CAA4CP,uBAAuBA,8BAA8BI,mBAAAA;wBAC5FH,8BAA8BK;;;oBAGlCD,uCAAuCC;;;;;;;sBAOrCH,UAAUK;;;;;;;;oCAQIE,eAAeD,KAAKD,QAAQL;;;;;;;;;;;;;;;uCAezBD,uBAAuBQ,sCAAsCX,4BAA4BY;;;MAG1HC,WAAWD,qBAAqBH,QAAQD"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.cts","names":["VectorStore","RecordManagerInterface","HashKeyEncoder","DocumentInterface","BaseDocumentLoader","Metadata","Record","IndexingResult","StringOrDocFunc","HashedDocumentInterface","HashedDocumentArgs","_HashedDocument","CleanupMode","IndexOptions","_batch","T","_deduplicateInOrder","_getSourceIdAssigner","_isBaseDocumentLoader","IndexArgs","index","Promise"],"sources":["../../src/indexing/base.d.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\nimport { RecordManagerInterface } from \"./record_manager.js\";\nimport { type HashKeyEncoder } from \"../utils/hash.js\";\nimport { DocumentInterface } from \"../documents/document.js\";\nimport { BaseDocumentLoader } from \"../document_loaders/base.js\";\ntype Metadata = Record<string, unknown>;\ntype IndexingResult = {\n    numAdded: number;\n    numDeleted: number;\n    numUpdated: number;\n    numSkipped: number;\n};\ntype StringOrDocFunc = string | ((doc: DocumentInterface) => string);\nexport interface HashedDocumentInterface extends DocumentInterface {\n    uid: string;\n    hash_?: string;\n    contentHash?: string;\n    metadataHash?: string;\n    pageContent: string;\n    metadata: Metadata;\n    calculateHashes(): void;\n    toDocument(): DocumentInterface;\n}\ninterface HashedDocumentArgs {\n    pageContent: string;\n    metadata: Metadata;\n    uid: string;\n}\n/**\n * HashedDocument is a Document with hashes calculated.\n * Hashes are calculated based on page content and metadata.\n * It is used for indexing.\n */\nexport declare class _HashedDocument implements HashedDocumentInterface {\n    uid: string;\n    hash_?: string;\n    contentHash?: string;\n    metadataHash?: string;\n    pageContent: string;\n    metadata: Metadata;\n    private keyEncoder;\n    constructor(fields: HashedDocumentArgs);\n    makeDefaultKeyEncoder(keyEncoderFn: HashKeyEncoder): void;\n    calculateHashes(): void;\n    toDocument(): DocumentInterface;\n    static fromDocument(document: DocumentInterface, uid?: string): _HashedDocument;\n    private _hashStringToUUID;\n    private _hashNestedDictToUUID;\n}\nexport type CleanupMode = \"full\" | \"incremental\";\nexport type IndexOptions = {\n    /**\n     * The number of documents to index in one batch.\n     */\n    batchSize?: number;\n    /**\n     * The cleanup mode to use. Can be \"full\", \"incremental\" or undefined.\n     * - **Incremental**: Cleans up all documents that haven't been updated AND\n     *   that are associated with source ids that were seen\n     *   during indexing.\n     *   Clean up is done continuously during indexing helping\n     *   to minimize the probability of users seeing duplicated\n     *   content.\n     * - **Full**: Delete all documents that haven to been returned by the loader.\n     *   Clean up runs after all documents have been indexed.\n     *   This means that users may see duplicated content during indexing.\n     * - **undefined**: Do not delete any documents.\n     */\n    cleanup?: CleanupMode;\n    /**\n     * Optional key that helps identify the original source of the document.\n     * Must either be a string representing the key of the source in the metadata\n     * or a function that takes a document and returns a string representing the source.\n     * **Required when cleanup is incremental**.\n     */\n    sourceIdKey?: StringOrDocFunc;\n    /**\n     * Batch size to use when cleaning up documents.\n     */\n    cleanupBatchSize?: number;\n    /**\n     * Force update documents even if they are present in the\n     * record manager. Useful if you are re-indexing with updated embeddings.\n     */\n    forceUpdate?: boolean;\n};\nexport declare function _batch<T>(size: number, iterable: T[]): T[][];\nexport declare function _deduplicateInOrder(hashedDocuments: HashedDocumentInterface[]): HashedDocumentInterface[];\nexport declare function _getSourceIdAssigner(sourceIdKey: StringOrDocFunc | null): (doc: DocumentInterface) => string | null;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare const _isBaseDocumentLoader: (arg: any) => arg is BaseDocumentLoader;\ninterface IndexArgs {\n    docsSource: BaseDocumentLoader | DocumentInterface[];\n    recordManager: RecordManagerInterface;\n    vectorStore: VectorStore;\n    options?: IndexOptions;\n}\n/**\n * Index data from the doc source into the vector store.\n *\n * Indexing functionality uses a manager to keep track of which documents\n * are in the vector store.\n *\n * This allows us to keep track of which documents were updated, and which\n * documents were deleted, which documents should be skipped.\n *\n * For the time being, documents are indexed using their hashes, and users\n *  are not able to specify the uid of the document.\n *\n * @param {IndexArgs} args\n * @param {BaseDocumentLoader | DocumentInterface[]} args.docsSource The source of documents to index. Can be a DocumentLoader or a list of Documents.\n * @param {RecordManagerInterface} args.recordManager The record manager to use for keeping track of indexed documents.\n * @param {VectorStore} args.vectorStore The vector store to use for storing the documents.\n * @param {IndexOptions | undefined} args.options Options for indexing.\n * @returns {Promise<IndexingResult>}\n */\nexport declare function index(args: IndexArgs): Promise<IndexingResult>;\nexport {};\n"],"mappings":";;;;;;;KAKKK,QAAAA,GAAWC;KACXC,cAAAA;EADAF,QAAAA,EAAAA,MAAQ;EACRE,UAAAA,EAAAA,MAAc;EAMdC,UAAAA,EAAAA,MAAe;EACHC,UAAAA,EAAAA,MAAAA;CAAuB;KADnCD,eAAAA,GAOSH,MAAAA,GAAAA,CAAAA,CAAAA,GAAAA,EAPyBF,iBAOzBE,EAAAA,GAAAA,MAAAA,CAAAA;AAEIF,UARDM,uBAAAA,SAAgCN,iBAQ/BA,CAAAA;EAAiB,GARcA,EAAAA,MAAAA;EAAiB,KAAA,CAAA,EAAA,MAAA;EAUxDO,WAAAA,CAAAA,EAAAA,MAAAA;EAUWC,YAAAA,CAAAA,EAAAA,MAAe;EAAA,WAAA,EAAA,MAAA;EAAA,QAMtBN,EApBAA,QAoBAA;EAAQ,eAEEK,EAAAA,EAAAA,IAAAA;EAAkB,UACFR,EAAAA,EArBtBC,iBAqBsBD;;UAnB9BQ,kBAAAA,CAsBwBP;EAAiB,WAAiBQ,EAAAA,MAAAA;EAAe,QAZnCF,EARlCJ,QAQkCI;EAAuB,GAAA,EAAA,MAAA;AAgBvE;AACA;;;;AAyBiC;AAWTK,cArDHH,eAAAA,YAA2BF,uBAqDlB,CAAA;EAAA,GAAA,EAAA,MAAA;EAAA,KAA4BM,CAAAA,EAAAA,MAAAA;EAAC,WAAKA,CAAAA,EAAAA,MAAAA;EAAC,YAAA,CAAA,EAAA,MAAA;EACzCC,WAAAA,EAAAA,MAAAA;EAAmB,QAAA,EAhD7BX,QAgD6B;EAAA,QAAkBI,UAAAA;EAAuB,WAAKA,CAAAA,MAAAA,EA9CjEC,kBA8CiED;EAAuB,qBAAA,CAAA,YAAA,EA7CxEP,cA6CwE,CAAA,EAAA,IAAA;EACxFe,eAAAA,CAAAA,CAAAA,EAAAA,IAAoB;EAAA,UAAA,CAAA,CAAA,EA5C1Bd,iBA4C0B;EAAA,OAAcK,YAAAA,CAAAA,QAAAA,EA3CxBL,iBA2CwBK,EAAAA,GAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EA3CUG,eA2CVH;EAAe,QAAgBL,iBAAAA;EAAiB,QAAA,qBAAA;AAE1G;AACUgB,KA1CEP,WAAAA,GA0CO,MAAA,GAAA,aAAA;AAAA,KAzCPC,YAAAA,GAyCO;EAAA;;;EAEsB,SACxBb,CAAAA,EAAAA,MAAAA;EAAW;AACF;AAqB1B;;;;;AAAuD;;;;;;YAhDzCY;;;;;;;gBAOIJ;;;;;;;;;;;iBAWMM,kCAAkCC,MAAMA;iBACxCC,mBAAAA,kBAAqCP,4BAA4BA;iBACjEQ,oBAAAA,cAAkCT,+BAA+BL;;cAEpEe,4CAA4Cd;UACvDe,SAAAA;cACMf,qBAAqBD;iBAClBF;eACFD;YACHa;;;;;;;;;;;;;;;;;;;;;iBAqBUO,KAAAA,OAAYD,YAAYE,QAAQd"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.ts","names":["VectorStore","RecordManagerInterface","HashKeyEncoder","DocumentInterface","BaseDocumentLoader","Metadata","Record","IndexingResult","StringOrDocFunc","HashedDocumentInterface","HashedDocumentArgs","_HashedDocument","CleanupMode","IndexOptions","_batch","T","_deduplicateInOrder","_getSourceIdAssigner","_isBaseDocumentLoader","IndexArgs","index","Promise"],"sources":["../../src/indexing/base.d.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\nimport { RecordManagerInterface } from \"./record_manager.js\";\nimport { type HashKeyEncoder } from \"../utils/hash.js\";\nimport { DocumentInterface } from \"../documents/document.js\";\nimport { BaseDocumentLoader } from \"../document_loaders/base.js\";\ntype Metadata = Record<string, unknown>;\ntype IndexingResult = {\n    numAdded: number;\n    numDeleted: number;\n    numUpdated: number;\n    numSkipped: number;\n};\ntype StringOrDocFunc = string | ((doc: DocumentInterface) => string);\nexport interface HashedDocumentInterface extends DocumentInterface {\n    uid: string;\n    hash_?: string;\n    contentHash?: string;\n    metadataHash?: string;\n    pageContent: string;\n    metadata: Metadata;\n    calculateHashes(): void;\n    toDocument(): DocumentInterface;\n}\ninterface HashedDocumentArgs {\n    pageContent: string;\n    metadata: Metadata;\n    uid: string;\n}\n/**\n * HashedDocument is a Document with hashes calculated.\n * Hashes are calculated based on page content and metadata.\n * It is used for indexing.\n */\nexport declare class _HashedDocument implements HashedDocumentInterface {\n    uid: string;\n    hash_?: string;\n    contentHash?: string;\n    metadataHash?: string;\n    pageContent: string;\n    metadata: Metadata;\n    private keyEncoder;\n    constructor(fields: HashedDocumentArgs);\n    makeDefaultKeyEncoder(keyEncoderFn: HashKeyEncoder): void;\n    calculateHashes(): void;\n    toDocument(): DocumentInterface;\n    static fromDocument(document: DocumentInterface, uid?: string): _HashedDocument;\n    private _hashStringToUUID;\n    private _hashNestedDictToUUID;\n}\nexport type CleanupMode = \"full\" | \"incremental\";\nexport type IndexOptions = {\n    /**\n     * The number of documents to index in one batch.\n     */\n    batchSize?: number;\n    /**\n     * The cleanup mode to use. Can be \"full\", \"incremental\" or undefined.\n     * - **Incremental**: Cleans up all documents that haven't been updated AND\n     *   that are associated with source ids that were seen\n     *   during indexing.\n     *   Clean up is done continuously during indexing helping\n     *   to minimize the probability of users seeing duplicated\n     *   content.\n     * - **Full**: Delete all documents that haven to been returned by the loader.\n     *   Clean up runs after all documents have been indexed.\n     *   This means that users may see duplicated content during indexing.\n     * - **undefined**: Do not delete any documents.\n     */\n    cleanup?: CleanupMode;\n    /**\n     * Optional key that helps identify the original source of the document.\n     * Must either be a string representing the key of the source in the metadata\n     * or a function that takes a document and returns a string representing the source.\n     * **Required when cleanup is incremental**.\n     */\n    sourceIdKey?: StringOrDocFunc;\n    /**\n     * Batch size to use when cleaning up documents.\n     */\n    cleanupBatchSize?: number;\n    /**\n     * Force update documents even if they are present in the\n     * record manager. Useful if you are re-indexing with updated embeddings.\n     */\n    forceUpdate?: boolean;\n};\nexport declare function _batch<T>(size: number, iterable: T[]): T[][];\nexport declare function _deduplicateInOrder(hashedDocuments: HashedDocumentInterface[]): HashedDocumentInterface[];\nexport declare function _getSourceIdAssigner(sourceIdKey: StringOrDocFunc | null): (doc: DocumentInterface) => string | null;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare const _isBaseDocumentLoader: (arg: any) => arg is BaseDocumentLoader;\ninterface IndexArgs {\n    docsSource: BaseDocumentLoader | DocumentInterface[];\n    recordManager: RecordManagerInterface;\n    vectorStore: VectorStore;\n    options?: IndexOptions;\n}\n/**\n * Index data from the doc source into the vector store.\n *\n * Indexing functionality uses a manager to keep track of which documents\n * are in the vector store.\n *\n * This allows us to keep track of which documents were updated, and which\n * documents were deleted, which documents should be skipped.\n *\n * For the time being, documents are indexed using their hashes, and users\n *  are not able to specify the uid of the document.\n *\n * @param {IndexArgs} args\n * @param {BaseDocumentLoader | DocumentInterface[]} args.docsSource The source of documents to index. Can be a DocumentLoader or a list of Documents.\n * @param {RecordManagerInterface} args.recordManager The record manager to use for keeping track of indexed documents.\n * @param {VectorStore} args.vectorStore The vector store to use for storing the documents.\n * @param {IndexOptions | undefined} args.options Options for indexing.\n * @returns {Promise<IndexingResult>}\n */\nexport declare function index(args: IndexArgs): Promise<IndexingResult>;\nexport {};\n"],"mappings":";;;;;;;KAKKK,QAAAA,GAAWC;KACXC,cAAAA;EADAF,QAAAA,EAAAA,MAAQ;EACRE,UAAAA,EAAAA,MAAc;EAMdC,UAAAA,EAAAA,MAAe;EACHC,UAAAA,EAAAA,MAAAA;CAAuB;KADnCD,eAAAA,GAOSH,MAAAA,GAAAA,CAAAA,CAAAA,GAAAA,EAPyBF,iBAOzBE,EAAAA,GAAAA,MAAAA,CAAAA;AAEIF,UARDM,uBAAAA,SAAgCN,iBAQ/BA,CAAAA;EAAiB,GARcA,EAAAA,MAAAA;EAAiB,KAAA,CAAA,EAAA,MAAA;EAUxDO,WAAAA,CAAAA,EAAAA,MAAAA;EAUWC,YAAAA,CAAAA,EAAAA,MAAe;EAAA,WAAA,EAAA,MAAA;EAAA,QAMtBN,EApBAA,QAoBAA;EAAQ,eAEEK,EAAAA,EAAAA,IAAAA;EAAkB,UACFR,EAAAA,EArBtBC,iBAqBsBD;;UAnB9BQ,kBAAAA,CAsBwBP;EAAiB,WAAiBQ,EAAAA,MAAAA;EAAe,QAZnCF,EARlCJ,QAQkCI;EAAuB,GAAA,EAAA,MAAA;AAgBvE;AACA;;;;AAyBiC;AAWTK,cArDHH,eAAAA,YAA2BF,uBAqDlB,CAAA;EAAA,GAAA,EAAA,MAAA;EAAA,KAA4BM,CAAAA,EAAAA,MAAAA;EAAC,WAAKA,CAAAA,EAAAA,MAAAA;EAAC,YAAA,CAAA,EAAA,MAAA;EACzCC,WAAAA,EAAAA,MAAAA;EAAmB,QAAA,EAhD7BX,QAgD6B;EAAA,QAAkBI,UAAAA;EAAuB,WAAKA,CAAAA,MAAAA,EA9CjEC,kBA8CiED;EAAuB,qBAAA,CAAA,YAAA,EA7CxEP,cA6CwE,CAAA,EAAA,IAAA;EACxFe,eAAAA,CAAAA,CAAAA,EAAAA,IAAoB;EAAA,UAAA,CAAA,CAAA,EA5C1Bd,iBA4C0B;EAAA,OAAcK,YAAAA,CAAAA,QAAAA,EA3CxBL,iBA2CwBK,EAAAA,GAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EA3CUG,eA2CVH;EAAe,QAAgBL,iBAAAA;EAAiB,QAAA,qBAAA;AAE1G;AACUgB,KA1CEP,WAAAA,GA0CO,MAAA,GAAA,aAAA;AAAA,KAzCPC,YAAAA,GAyCO;EAAA;;;EAEsB,SACxBb,CAAAA,EAAAA,MAAAA;EAAW;AACF;AAqB1B;;;;;AAAuD;;;;;;YAhDzCY;;;;;;;gBAOIJ;;;;;;;;;;;iBAWMM,kCAAkCC,MAAMA;iBACxCC,mBAAAA,kBAAqCP,4BAA4BA;iBACjEQ,oBAAAA,cAAkCT,+BAA+BL;;cAEpEe,4CAA4Cd;UACvDe,SAAAA;cACMf,qBAAqBD;iBAClBF;eACFD;YACHa;;;;;;;;;;;;;;;;;;;;;iBAqBUO,KAAAA,OAAYD,YAAYE,QAAQd"}

package/dist/indexing/record_manager.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"record_manager.d.cts","names":["Serializable","UUIDV5_NAMESPACE","UpdateOptions","ListKeyOptions","RecordManagerInterface","Promise","RecordManager"],"sources":["../../src/indexing/record_manager.d.ts"],"sourcesContent":["import { Serializable } from \"../load/serializable.js\";\n// Arbitrary value, used for generating namespaced UUIDs.\nexport declare const UUIDV5_NAMESPACE = \"10f90ea3-90a4-4962-bf75-83a0f3c1c62a\";\nexport type UpdateOptions = {\n    groupIds?: (string | null)[];\n    timeAtLeast?: number;\n};\nexport type ListKeyOptions = {\n    before?: number;\n    after?: number;\n    groupIds?: (string | null)[];\n    limit?: number;\n};\nexport interface RecordManagerInterface {\n    /**\n     * Creates schema in the record manager.\n     * @returns Promise\n     */\n    createSchema(): Promise<void>;\n    /**\n     * Returns current time from the record manager.\n     * @returns Current time\n     */\n    getTime(): Promise<number>;\n    /**\n     * Updates keys in the record manager.\n     * @param keys List of keys to update\n     * @param groupIds List of groupIds to update\n     * @param timeAtLeast Update only if current time is at least this value\n     * @returns Promise\n     * @throws Error if timeAtLeast is provided and current time is less than timeAtLeast\n     * @throws Error if number of keys does not match number of groupIds\n     */\n    update(keys: string[], updateOptions: UpdateOptions): Promise<void>;\n    /**\n     * Checks if keys exist in the record manager.\n     * @param keys List of keys to check\n     * @returns List of booleans indicating if key exists in same order as provided keys\n     */\n    exists(keys: string[]): Promise<boolean[]>;\n    /**\n     * Lists keys from the record manager.\n     * @param before List keys before this timestamp\n     * @param after List keys after this timestamp\n     * @param groupIds List keys with these groupIds\n     * @param limit Limit the number of keys returned\n     * @returns List of keys\n     *\n     */\n    listKeys(options: ListKeyOptions): Promise<string[]>;\n    /**\n     * Deletes keys from the record manager.\n     * @param keys List of keys to delete\n     */\n    deleteKeys(keys: string[]): Promise<void>;\n}\nexport declare abstract class RecordManager extends Serializable implements RecordManagerInterface {\n    lc_namespace: string[];\n    abstract createSchema(): Promise<void>;\n    abstract getTime(): Promise<number>;\n    abstract update(keys: string[], updateOptions?: UpdateOptions): Promise<void>;\n    abstract exists(keys: string[]): Promise<boolean[]>;\n    abstract listKeys(options?: ListKeyOptions): Promise<string[]>;\n    abstract deleteKeys(keys: string[]): Promise<void>;\n}\n"],"mappings":";;;;cAEqBC,gBAAAA;AAAAA,KACTC,aAAAA,GADyB;EACzBA,QAAAA,CAAAA,EAAAA,CAAAA,MAAa,GAAA,IAAA,CAAA,EAAA;EAIbC,WAAAA,CAAAA,EAAAA,MAAc;AAM1B,CAAA;AAAuC,KAN3BA,cAAAA,GAM2B;EAAA,MAKnBE,CAAAA,EAAAA,MAAAA;EAAO,KAKZA,CAAAA,EAAAA,MAAAA;EAAO,QAUoBH,CAAAA,EAAAA,CAAAA,MAAAA,GAAAA,IAAAA,CAAAA,EAAAA;EAAa,KAAGG,CAAAA,EAAAA,MAAAA;CAAO;AAgB3CF,UApCLC,sBAAAA,CAoCKD;EAAc;;AAKG;AAEvC;EAA2C,YAAA,EAAA,EAtCvBE,OAsCuB,CAAA,IAAA,CAAA;EAAA;;;;EAIgC,OACtCA,EAAAA,EAtCtBA,OAsCsBA,CAAAA,MAAAA,CAAAA;EAAO;;;;;AALsD;;;;wCAvBxDH,gBAAgBG;;;;;;0BAM9BA;;;;;;;;;;oBAUNF,iBAAiBE;;;;;8BAKPA;;uBAEFC,aAAAA,SAAsBN,YAAAA,YAAwBI;;2BAE/CC;sBACLA;kDAC4BH,gBAAgBG;mCAC/BA;8BACLF,iBAAiBE;uCACRA"}

package/dist/indexing/record_manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"record_manager.d.ts","names":["Serializable","UUIDV5_NAMESPACE","UpdateOptions","ListKeyOptions","RecordManagerInterface","Promise","RecordManager"],"sources":["../../src/indexing/record_manager.d.ts"],"sourcesContent":["import { Serializable } from \"../load/serializable.js\";\n// Arbitrary value, used for generating namespaced UUIDs.\nexport declare const UUIDV5_NAMESPACE = \"10f90ea3-90a4-4962-bf75-83a0f3c1c62a\";\nexport type UpdateOptions = {\n    groupIds?: (string | null)[];\n    timeAtLeast?: number;\n};\nexport type ListKeyOptions = {\n    before?: number;\n    after?: number;\n    groupIds?: (string | null)[];\n    limit?: number;\n};\nexport interface RecordManagerInterface {\n    /**\n     * Creates schema in the record manager.\n     * @returns Promise\n     */\n    createSchema(): Promise<void>;\n    /**\n     * Returns current time from the record manager.\n     * @returns Current time\n     */\n    getTime(): Promise<number>;\n    /**\n     * Updates keys in the record manager.\n     * @param keys List of keys to update\n     * @param groupIds List of groupIds to update\n     * @param timeAtLeast Update only if current time is at least this value\n     * @returns Promise\n     * @throws Error if timeAtLeast is provided and current time is less than timeAtLeast\n     * @throws Error if number of keys does not match number of groupIds\n     */\n    update(keys: string[], updateOptions: UpdateOptions): Promise<void>;\n    /**\n     * Checks if keys exist in the record manager.\n     * @param keys List of keys to check\n     * @returns List of booleans indicating if key exists in same order as provided keys\n     */\n    exists(keys: string[]): Promise<boolean[]>;\n    /**\n     * Lists keys from the record manager.\n     * @param before List keys before this timestamp\n     * @param after List keys after this timestamp\n     * @param groupIds List keys with these groupIds\n     * @param limit Limit the number of keys returned\n     * @returns List of keys\n     *\n     */\n    listKeys(options: ListKeyOptions): Promise<string[]>;\n    /**\n     * Deletes keys from the record manager.\n     * @param keys List of keys to delete\n     */\n    deleteKeys(keys: string[]): Promise<void>;\n}\nexport declare abstract class RecordManager extends Serializable implements RecordManagerInterface {\n    lc_namespace: string[];\n    abstract createSchema(): Promise<void>;\n    abstract getTime(): Promise<number>;\n    abstract update(keys: string[], updateOptions?: UpdateOptions): Promise<void>;\n    abstract exists(keys: string[]): Promise<boolean[]>;\n    abstract listKeys(options?: ListKeyOptions): Promise<string[]>;\n    abstract deleteKeys(keys: string[]): Promise<void>;\n}\n"],"mappings":";;;;cAEqBC,gBAAAA;AAAAA,KACTC,aAAAA,GADyB;EACzBA,QAAAA,CAAAA,EAAAA,CAAAA,MAAa,GAAA,IAAA,CAAA,EAAA;EAIbC,WAAAA,CAAAA,EAAAA,MAAc;AAM1B,CAAA;AAAuC,KAN3BA,cAAAA,GAM2B;EAAA,MAKnBE,CAAAA,EAAAA,MAAAA;EAAO,KAKZA,CAAAA,EAAAA,MAAAA;EAAO,QAUoBH,CAAAA,EAAAA,CAAAA,MAAAA,GAAAA,IAAAA,CAAAA,EAAAA;EAAa,KAAGG,CAAAA,EAAAA,MAAAA;CAAO;AAgB3CF,UApCLC,sBAAAA,CAoCKD;EAAc;;AAKG;AAEvC;EAA2C,YAAA,EAAA,EAtCvBE,OAsCuB,CAAA,IAAA,CAAA;EAAA;;;;EAIgC,OACtCA,EAAAA,EAtCtBA,OAsCsBA,CAAAA,MAAAA,CAAAA;EAAO;;;;;AALsD;;;;wCAvBxDH,gBAAgBG;;;;;;0BAM9BA;;;;;;;;;;oBAUNF,iBAAiBE;;;;;8BAKPA;;uBAEFC,aAAAA,SAAsBN,YAAAA,YAAwBI;;2BAE/CC;sBACLA;kDAC4BH,gBAAgBG;mCAC/BA;8BACLF,iBAAiBE;uCACRA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.cts","names":["TiktokenModel","ZodType","ZodTypeV3","$ZodType","ZodTypeV4","BaseCache","BasePromptValueInterface","BaseMessage","BaseMessageLike","MessageContent","LLMResult","CallbackManager","Callbacks","AsyncCaller","AsyncCallerParams","Runnable","RunnableInterface","RunnableConfig","JSONSchema","InferInteropZodOutput","InteropZodObject","InteropZodType","ModelProfile","getModelNameForTiktoken","getEmbeddingContextSize","getModelContextSize","isOpenAITool","ToolDefinition","CalculateMaxTokenProps","calculateMaxTokens","prompt","modelName","Promise","SerializedLLM","Record","BaseLangChainParams","BaseLangChain","RunInput","RunOutput","CallOptions","BaseLanguageModelParams","BaseLanguageModelTracingCallOptions","BaseLanguageModelCallOptions","FunctionDefinition","FunctionCallOption","BaseFunctionCallOptions","BaseLanguageModelInput","StructuredOutputType","StructuredOutputMethodOptions","IncludeRaw","StructuredOutputMethodParams","BaseLanguageModelInterface","LanguageModelOutput","LanguageModelLike","BaseLanguageModel","callbacks","callbackManager","config","TokenUsage"],"sources":["../../src/language_models/base.d.ts"],"sourcesContent":["import type { TiktokenModel } from \"js-tiktoken/lite\";\nimport type { ZodType as ZodTypeV3 } from \"zod/v3\";\nimport type { $ZodType as ZodTypeV4 } from \"zod/v4/core\";\nimport { type BaseCache } from \"../caches/base.js\";\nimport { type BasePromptValueInterface } from \"../prompt_values.js\";\nimport { type BaseMessage, type BaseMessageLike, type MessageContent } from \"../messages/base.js\";\nimport { type LLMResult } from \"../outputs.js\";\nimport { CallbackManager, Callbacks } from \"../callbacks/manager.js\";\nimport { AsyncCaller, AsyncCallerParams } from \"../utils/async_caller.js\";\nimport { Runnable, type RunnableInterface } from \"../runnables/base.js\";\nimport { RunnableConfig } from \"../runnables/config.js\";\nimport { JSONSchema } from \"../utils/json_schema.js\";\nimport { InferInteropZodOutput, InteropZodObject, InteropZodType } from \"../utils/types/zod.js\";\nimport { ModelProfile } from \"./profile.js\";\n// https://www.npmjs.com/package/js-tiktoken\nexport declare const getModelNameForTiktoken: (modelName: string) => TiktokenModel;\nexport declare const getEmbeddingContextSize: (modelName?: string | undefined) => number;\n/**\n * Get the context window size (max input tokens) for a given model.\n *\n * Context window sizes are sourced from official model documentation:\n * - OpenAI: https://platform.openai.com/docs/models\n * - Anthropic: https://docs.anthropic.com/claude/docs/models-overview\n * - Google: https://ai.google.dev/gemini/docs/models/gemini\n *\n * @param modelName - The name of the model\n * @returns The context window size in tokens\n */\nexport declare const getModelContextSize: (modelName: string) => number;\n/**\n * Whether or not the input matches the OpenAI tool definition.\n * @param {unknown} tool The input to check.\n * @returns {boolean} Whether the input is an OpenAI tool definition.\n */\nexport declare function isOpenAITool(tool: unknown): tool is ToolDefinition;\ninterface CalculateMaxTokenProps {\n    prompt: string;\n    modelName: TiktokenModel;\n}\nexport declare const calculateMaxTokens: ({ prompt, modelName, }: CalculateMaxTokenProps) => Promise<number>;\nexport type SerializedLLM = {\n    _model: string;\n    _type: string;\n} & Record<string, any>;\nexport interface BaseLangChainParams {\n    verbose?: boolean;\n    callbacks?: Callbacks;\n    tags?: string[];\n    metadata?: Record<string, unknown>;\n}\n/**\n * Base class for language models, chains, tools.\n */\nexport declare abstract class BaseLangChain<RunInput, RunOutput, CallOptions extends RunnableConfig = RunnableConfig> extends Runnable<RunInput, RunOutput, CallOptions> implements BaseLangChainParams {\n    /**\n     * Whether to print out response text.\n     */\n    verbose: boolean;\n    callbacks?: Callbacks;\n    tags?: string[];\n    metadata?: Record<string, unknown>;\n    get lc_attributes(): {\n        [key: string]: undefined;\n    } | undefined;\n    constructor(params: BaseLangChainParams);\n}\n/**\n * Base interface for language model parameters.\n * A subclass of {@link BaseLanguageModel} should have a constructor that\n * takes in a parameter that extends this interface.\n */\nexport interface BaseLanguageModelParams extends AsyncCallerParams, BaseLangChainParams {\n    /**\n     * @deprecated Use `callbacks` instead\n     */\n    callbackManager?: CallbackManager;\n    cache?: BaseCache | boolean;\n}\nexport interface BaseLanguageModelTracingCallOptions {\n    /**\n     * Describes the format of structured outputs.\n     * This should be provided if an output is considered to be structured\n     */\n    ls_structured_output_format?: {\n        /**\n         * An object containing the method used for structured output (e.g., \"jsonMode\").\n         */\n        kwargs: {\n            method: string;\n        };\n        /**\n         * The JSON schema describing the expected output structure.\n         */\n        schema?: JSONSchema;\n    };\n}\nexport interface BaseLanguageModelCallOptions extends RunnableConfig, BaseLanguageModelTracingCallOptions {\n    /**\n     * Stop tokens to use for this call.\n     * If not provided, the default stop tokens for the model will be used.\n     */\n    stop?: string[];\n}\nexport interface FunctionDefinition {\n    /**\n     * The name of the function to be called. Must be a-z, A-Z, 0-9, or contain\n     * underscores and dashes, with a maximum length of 64.\n     */\n    name: string;\n    /**\n     * The parameters the functions accepts, described as a JSON Schema object. See the\n     * [guide](https://platform.openai.com/docs/guides/gpt/function-calling) for\n     * examples, and the\n     * [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for\n     * documentation about the format.\n     *\n     * To describe a function that accepts no parameters, provide the value\n     * `{\"type\": \"object\", \"properties\": {}}`.\n     */\n    parameters: Record<string, unknown> | JSONSchema;\n    /**\n     * A description of what the function does, used by the model to choose when and\n     * how to call the function.\n     */\n    description?: string;\n}\nexport interface ToolDefinition {\n    type: \"function\";\n    function: FunctionDefinition;\n}\nexport type FunctionCallOption = {\n    name: string;\n};\nexport interface BaseFunctionCallOptions extends BaseLanguageModelCallOptions {\n    function_call?: FunctionCallOption;\n    functions?: FunctionDefinition[];\n}\nexport type BaseLanguageModelInput = BasePromptValueInterface | string | BaseMessageLike[];\nexport type StructuredOutputType = InferInteropZodOutput<InteropZodObject>;\nexport type StructuredOutputMethodOptions<IncludeRaw extends boolean = false> = {\n    name?: string;\n    method?: \"functionCalling\" | \"jsonMode\" | \"jsonSchema\" | string;\n    includeRaw?: IncludeRaw;\n    /** Whether to use strict mode. Currently only supported by OpenAI models. */\n    strict?: boolean;\n};\n/** @deprecated Use StructuredOutputMethodOptions instead */\nexport type StructuredOutputMethodParams<RunOutput, IncludeRaw extends boolean = false> = {\n    /** @deprecated Pass schema in as the first argument */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    schema: InteropZodType<RunOutput> | Record<string, any>;\n    name?: string;\n    method?: \"functionCalling\" | \"jsonMode\";\n    includeRaw?: IncludeRaw;\n};\nexport interface BaseLanguageModelInterface<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nRunOutput = any, CallOptions extends BaseLanguageModelCallOptions = BaseLanguageModelCallOptions> extends RunnableInterface<BaseLanguageModelInput, RunOutput, CallOptions> {\n    get callKeys(): string[];\n    generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    _modelType(): string;\n    _llmType(): string;\n    getNumTokens(content: MessageContent): Promise<number>;\n    /**\n     * Get the identifying parameters of the LLM.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    _identifyingParams(): Record<string, any>;\n    serialize(): SerializedLLM;\n}\nexport type LanguageModelOutput = BaseMessage | string;\nexport type LanguageModelLike = Runnable<BaseLanguageModelInput, LanguageModelOutput>;\n/**\n * Base class for language models.\n */\nexport declare abstract class BaseLanguageModel<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nRunOutput = any, CallOptions extends BaseLanguageModelCallOptions = BaseLanguageModelCallOptions> extends BaseLangChain<BaseLanguageModelInput, RunOutput, CallOptions> implements BaseLanguageModelParams, BaseLanguageModelInterface<RunOutput, CallOptions> {\n    /**\n     * Keys that the language model accepts as call options.\n     */\n    get callKeys(): string[];\n    /**\n     * The async caller should be used by subclasses to make any async calls,\n     * which will thus benefit from the concurrency and retry logic.\n     */\n    caller: AsyncCaller;\n    cache?: BaseCache;\n    constructor({ callbacks, callbackManager, ...params }: BaseLanguageModelParams);\n    abstract generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    abstract _modelType(): string;\n    abstract _llmType(): string;\n    private _encoding?;\n    /**\n     * Get the number of tokens in the content.\n     * @param content The content to get the number of tokens for.\n     * @returns The number of tokens in the content.\n     */\n    getNumTokens(content: MessageContent): Promise<number>;\n    protected static _convertInputToPromptValue(input: BaseLanguageModelInput): BasePromptValueInterface;\n    /**\n     * Get the identifying parameters of the LLM.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    _identifyingParams(): Record<string, any>;\n    /**\n     * Create a unique cache key for a specific call to a specific language model.\n     * @param callOptions Call options for the model\n     * @returns A unique cache key.\n     */\n    _getSerializedCacheKeyParametersForCall(\n    // TODO: Fix when we remove the RunnableLambda backwards compatibility shim.\n    { config, ...callOptions }: CallOptions & {\n        config?: RunnableConfig;\n    }): string;\n    /**\n     * @deprecated\n     * Return a json-like object representing this LLM.\n     */\n    serialize(): SerializedLLM;\n    /**\n     * @deprecated\n     * Load an LLM from a json-like object describing it.\n     */\n    static deserialize(_data: SerializedLLM): Promise<BaseLanguageModel>;\n    /**\n     * Return profiling information for the model.\n     *\n     * @returns {ModelProfile} An object describing the model's capabilities and constraints\n     */\n    get profile(): ModelProfile;\n    withStructuredOutput?<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>>(schema: ZodTypeV3<RunOutput>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n     | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n    withStructuredOutput?<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>>(schema: ZodTypeV3<RunOutput>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n     | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n    withStructuredOutput?<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>>(schema: ZodTypeV4<RunOutput>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n     | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n    withStructuredOutput?<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>>(schema: ZodTypeV4<RunOutput>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n     | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n    /**\n     * Model wrapper that returns outputs formatted to match the given schema.\n     *\n     * @template {BaseLanguageModelInput} RunInput The input type for the Runnable, expected to be the same input for the LLM.\n     * @template {Record<string, any>} RunOutput The output type for the Runnable, expected to be a Zod schema object for structured output validation.\n     *\n     * @param {InteropZodType<RunOutput>} schema The schema for the structured output. Either as a Zod schema or a valid JSON schema object.\n     *   If a Zod schema is passed, the returned attributes will be validated, whereas with JSON schema they will not be.\n     * @param {string} name The name of the function to call.\n     * @param {\"functionCalling\" | \"jsonMode\"} [method=functionCalling] The method to use for getting the structured output. Defaults to \"functionCalling\".\n     * @param {boolean | undefined} [includeRaw=false] Whether to include the raw output in the result. Defaults to false.\n     * @returns {Runnable<RunInput, RunOutput> | Runnable<RunInput, { raw: BaseMessage; parsed: RunOutput }>} A new runnable that calls the LLM with structured output.\n     */\n    withStructuredOutput?<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>>(schema: InteropZodType<RunOutput>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n     | Record<string, any>, config?: StructuredOutputMethodOptions<boolean>): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n}\n/**\n * Shared interface for token usage\n * return type from LLM calls.\n */\nexport interface TokenUsage {\n    completionTokens?: number;\n    promptTokens?: number;\n    totalTokens?: number;\n}\nexport {};\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.ts","names":["TiktokenModel","ZodType","ZodTypeV3","$ZodType","ZodTypeV4","BaseCache","BasePromptValueInterface","BaseMessage","BaseMessageLike","MessageContent","LLMResult","CallbackManager","Callbacks","AsyncCaller","AsyncCallerParams","Runnable","RunnableInterface","RunnableConfig","JSONSchema","InferInteropZodOutput","InteropZodObject","InteropZodType","ModelProfile","getModelNameForTiktoken","getEmbeddingContextSize","getModelContextSize","isOpenAITool","ToolDefinition","CalculateMaxTokenProps","calculateMaxTokens","prompt","modelName","Promise","SerializedLLM","Record","BaseLangChainParams","BaseLangChain","RunInput","RunOutput","CallOptions","BaseLanguageModelParams","BaseLanguageModelTracingCallOptions","BaseLanguageModelCallOptions","FunctionDefinition","FunctionCallOption","BaseFunctionCallOptions","BaseLanguageModelInput","StructuredOutputType","StructuredOutputMethodOptions","IncludeRaw","StructuredOutputMethodParams","BaseLanguageModelInterface","LanguageModelOutput","LanguageModelLike","BaseLanguageModel","callbacks","callbackManager","config","TokenUsage"],"sources":["../../src/language_models/base.d.ts"],"sourcesContent":["import type { TiktokenModel } from \"js-tiktoken/lite\";\nimport type { ZodType as ZodTypeV3 } from \"zod/v3\";\nimport type { $ZodType as ZodTypeV4 } from \"zod/v4/core\";\nimport { type BaseCache } from \"../caches/base.js\";\nimport { type BasePromptValueInterface } from \"../prompt_values.js\";\nimport { type BaseMessage, type BaseMessageLike, type MessageContent } from \"../messages/base.js\";\nimport { type LLMResult } from \"../outputs.js\";\nimport { CallbackManager, Callbacks } from \"../callbacks/manager.js\";\nimport { AsyncCaller, AsyncCallerParams } from \"../utils/async_caller.js\";\nimport { Runnable, type RunnableInterface } from \"../runnables/base.js\";\nimport { RunnableConfig } from \"../runnables/config.js\";\nimport { JSONSchema } from \"../utils/json_schema.js\";\nimport { InferInteropZodOutput, InteropZodObject, InteropZodType } from \"../utils/types/zod.js\";\nimport { ModelProfile } from \"./profile.js\";\n// https://www.npmjs.com/package/js-tiktoken\nexport declare const getModelNameForTiktoken: (modelName: string) => TiktokenModel;\nexport declare const getEmbeddingContextSize: (modelName?: string | undefined) => number;\n/**\n * Get the context window size (max input tokens) for a given model.\n *\n * Context window sizes are sourced from official model documentation:\n * - OpenAI: https://platform.openai.com/docs/models\n * - Anthropic: https://docs.anthropic.com/claude/docs/models-overview\n * - Google: https://ai.google.dev/gemini/docs/models/gemini\n *\n * @param modelName - The name of the model\n * @returns The context window size in tokens\n */\nexport declare const getModelContextSize: (modelName: string) => number;\n/**\n * Whether or not the input matches the OpenAI tool definition.\n * @param {unknown} tool The input to check.\n * @returns {boolean} Whether the input is an OpenAI tool definition.\n */\nexport declare function isOpenAITool(tool: unknown): tool is ToolDefinition;\ninterface CalculateMaxTokenProps {\n    prompt: string;\n    modelName: TiktokenModel;\n}\nexport declare const calculateMaxTokens: ({ prompt, modelName, }: CalculateMaxTokenProps) => Promise<number>;\nexport type SerializedLLM = {\n    _model: string;\n    _type: string;\n} & Record<string, any>;\nexport interface BaseLangChainParams {\n    verbose?: boolean;\n    callbacks?: Callbacks;\n    tags?: string[];\n    metadata?: Record<string, unknown>;\n}\n/**\n * Base class for language models, chains, tools.\n */\nexport declare abstract class BaseLangChain<RunInput, RunOutput, CallOptions extends RunnableConfig = RunnableConfig> extends Runnable<RunInput, RunOutput, CallOptions> implements BaseLangChainParams {\n    /**\n     * Whether to print out response text.\n     */\n    verbose: boolean;\n    callbacks?: Callbacks;\n    tags?: string[];\n    metadata?: Record<string, unknown>;\n    get lc_attributes(): {\n        [key: string]: undefined;\n    } | undefined;\n    constructor(params: BaseLangChainParams);\n}\n/**\n * Base interface for language model parameters.\n * A subclass of {@link BaseLanguageModel} should have a constructor that\n * takes in a parameter that extends this interface.\n */\nexport interface BaseLanguageModelParams extends AsyncCallerParams, BaseLangChainParams {\n    /**\n     * @deprecated Use `callbacks` instead\n     */\n    callbackManager?: CallbackManager;\n    cache?: BaseCache | boolean;\n}\nexport interface BaseLanguageModelTracingCallOptions {\n    /**\n     * Describes the format of structured outputs.\n     * This should be provided if an output is considered to be structured\n     */\n    ls_structured_output_format?: {\n        /**\n         * An object containing the method used for structured output (e.g., \"jsonMode\").\n         */\n        kwargs: {\n            method: string;\n        };\n        /**\n         * The JSON schema describing the expected output structure.\n         */\n        schema?: JSONSchema;\n    };\n}\nexport interface BaseLanguageModelCallOptions extends RunnableConfig, BaseLanguageModelTracingCallOptions {\n    /**\n     * Stop tokens to use for this call.\n     * If not provided, the default stop tokens for the model will be used.\n     */\n    stop?: string[];\n}\nexport interface FunctionDefinition {\n    /**\n     * The name of the function to be called. Must be a-z, A-Z, 0-9, or contain\n     * underscores and dashes, with a maximum length of 64.\n     */\n    name: string;\n    /**\n     * The parameters the functions accepts, described as a JSON Schema object. See the\n     * [guide](https://platform.openai.com/docs/guides/gpt/function-calling) for\n     * examples, and the\n     * [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for\n     * documentation about the format.\n     *\n     * To describe a function that accepts no parameters, provide the value\n     * `{\"type\": \"object\", \"properties\": {}}`.\n     */\n    parameters: Record<string, unknown> | JSONSchema;\n    /**\n     * A description of what the function does, used by the model to choose when and\n     * how to call the function.\n     */\n    description?: string;\n}\nexport interface ToolDefinition {\n    type: \"function\";\n    function: FunctionDefinition;\n}\nexport type FunctionCallOption = {\n    name: string;\n};\nexport interface BaseFunctionCallOptions extends BaseLanguageModelCallOptions {\n    function_call?: FunctionCallOption;\n    functions?: FunctionDefinition[];\n}\nexport type BaseLanguageModelInput = BasePromptValueInterface | string | BaseMessageLike[];\nexport type StructuredOutputType = InferInteropZodOutput<InteropZodObject>;\nexport type StructuredOutputMethodOptions<IncludeRaw extends boolean = false> = {\n    name?: string;\n    method?: \"functionCalling\" | \"jsonMode\" | \"jsonSchema\" | string;\n    includeRaw?: IncludeRaw;\n    /** Whether to use strict mode. Currently only supported by OpenAI models. */\n    strict?: boolean;\n};\n/** @deprecated Use StructuredOutputMethodOptions instead */\nexport type StructuredOutputMethodParams<RunOutput, IncludeRaw extends boolean = false> = {\n    /** @deprecated Pass schema in as the first argument */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    schema: InteropZodType<RunOutput> | Record<string, any>;\n    name?: string;\n    method?: \"functionCalling\" | \"jsonMode\";\n    includeRaw?: IncludeRaw;\n};\nexport interface BaseLanguageModelInterface<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nRunOutput = any, CallOptions extends BaseLanguageModelCallOptions = BaseLanguageModelCallOptions> extends RunnableInterface<BaseLanguageModelInput, RunOutput, CallOptions> {\n    get callKeys(): string[];\n    generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    _modelType(): string;\n    _llmType(): string;\n    getNumTokens(content: MessageContent): Promise<number>;\n    /**\n     * Get the identifying parameters of the LLM.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    _identifyingParams(): Record<string, any>;\n    serialize(): SerializedLLM;\n}\nexport type LanguageModelOutput = BaseMessage | string;\nexport type LanguageModelLike = Runnable<BaseLanguageModelInput, LanguageModelOutput>;\n/**\n * Base class for language models.\n */\nexport declare abstract class BaseLanguageModel<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nRunOutput = any, CallOptions extends BaseLanguageModelCallOptions = BaseLanguageModelCallOptions> extends BaseLangChain<BaseLanguageModelInput, RunOutput, CallOptions> implements BaseLanguageModelParams, BaseLanguageModelInterface<RunOutput, CallOptions> {\n    /**\n     * Keys that the language model accepts as call options.\n     */\n    get callKeys(): string[];\n    /**\n     * The async caller should be used by subclasses to make any async calls,\n     * which will thus benefit from the concurrency and retry logic.\n     */\n    caller: AsyncCaller;\n    cache?: BaseCache;\n    constructor({ callbacks, callbackManager, ...params }: BaseLanguageModelParams);\n    abstract generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    abstract _modelType(): string;\n    abstract _llmType(): string;\n    private _encoding?;\n    /**\n     * Get the number of tokens in the content.\n     * @param content The content to get the number of tokens for.\n     * @returns The number of tokens in the content.\n     */\n    getNumTokens(content: MessageContent): Promise<number>;\n    protected static _convertInputToPromptValue(input: BaseLanguageModelInput): BasePromptValueInterface;\n    /**\n     * Get the identifying parameters of the LLM.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    _identifyingParams(): Record<string, any>;\n    /**\n     * Create a unique cache key for a specific call to a specific language model.\n     * @param callOptions Call options for the model\n     * @returns A unique cache key.\n     */\n    _getSerializedCacheKeyParametersForCall(\n    // TODO: Fix when we remove the RunnableLambda backwards compatibility shim.\n    { config, ...callOptions }: CallOptions & {\n        config?: RunnableConfig;\n    }): string;\n    /**\n     * @deprecated\n     * Return a json-like object representing this LLM.\n     */\n    serialize(): SerializedLLM;\n    /**\n     * @deprecated\n     * Load an LLM from a json-like object describing it.\n     */\n    static deserialize(_data: SerializedLLM): Promise<BaseLanguageModel>;\n    /**\n     * Return profiling information for the model.\n     *\n     * @returns {ModelProfile} An object describing the model's capabilities and constraints\n     */\n    get profile(): ModelProfile;\n    withStructuredOutput?<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>>(schema: ZodTypeV3<RunOutput>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n     | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n    withStructuredOutput?<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>>(schema: ZodTypeV3<RunOutput>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n     | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n    withStructuredOutput?<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>>(schema: ZodTypeV4<RunOutput>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n     | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n    withStructuredOutput?<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>>(schema: ZodTypeV4<RunOutput>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n     | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n    /**\n     * Model wrapper that returns outputs formatted to match the given schema.\n     *\n     * @template {BaseLanguageModelInput} RunInput The input type for the Runnable, expected to be the same input for the LLM.\n     * @template {Record<string, any>} RunOutput The output type for the Runnable, expected to be a Zod schema object for structured output validation.\n     *\n     * @param {InteropZodType<RunOutput>} schema The schema for the structured output. Either as a Zod schema or a valid JSON schema object.\n     *   If a Zod schema is passed, the returned attributes will be validated, whereas with JSON schema they will not be.\n     * @param {string} name The name of the function to call.\n     * @param {\"functionCalling\" | \"jsonMode\"} [method=functionCalling] The method to use for getting the structured output. Defaults to \"functionCalling\".\n     * @param {boolean | undefined} [includeRaw=false] Whether to include the raw output in the result. Defaults to false.\n     * @returns {Runnable<RunInput, RunOutput> | Runnable<RunInput, { raw: BaseMessage; parsed: RunOutput }>} A new runnable that calls the LLM with structured output.\n     */\n    withStructuredOutput?<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>>(schema: InteropZodType<RunOutput>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n     | Record<string, any>, config?: StructuredOutputMethodOptions<boolean>): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n}\n/**\n * Shared interface for token usage\n * return type from LLM calls.\n */\nexport interface TokenUsage {\n    completionTokens?: number;\n    promptTokens?: number;\n    totalTokens?: number;\n}\nexport {};\n"],"mappings":"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"}

package/dist/language_models/chat_models.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chat_models.d.cts","names":["ZodType","ZodTypeV3","$ZodType","ZodTypeV4","BaseMessage","BaseMessageChunk","BaseMessageLike","AIMessageChunk","MessageOutputVersion","BasePromptValueInterface","LLMResult","ChatGenerationChunk","ChatResult","Generation","BaseLanguageModel","StructuredOutputMethodOptions","ToolDefinition","BaseLanguageModelCallOptions","BaseLanguageModelInput","BaseLanguageModelParams","CallbackManagerForLLMRun","Callbacks","RunnableConfig","BaseCache","StructuredToolInterface","StructuredToolParams","Runnable","RunnableToolLike","ToolChoice","Record","SerializedChatModel","SerializedLLM","BaseChatModelParams","BaseChatModelCallOptions","LangSmithParams","Array","BindToolsInput","BaseChatModel","OutputMessageType","CallOptions","Exclude","Omit","Partial","Promise","AsyncGenerator","messages","cache","llmStringKey","parsedOptions","handledOptions","RunOutput","SimpleChatModel"],"sources":["../../src/language_models/chat_models.d.ts"],"sourcesContent":["import type { ZodType as ZodTypeV3 } from \"zod/v3\";\nimport type { $ZodType as ZodTypeV4 } from \"zod/v4/core\";\nimport { type BaseMessage, BaseMessageChunk, type BaseMessageLike, AIMessageChunk, MessageOutputVersion } from \"../messages/index.js\";\nimport type { BasePromptValueInterface } from \"../prompt_values.js\";\nimport { LLMResult, ChatGenerationChunk, type ChatResult, type Generation } from \"../outputs.js\";\nimport { BaseLanguageModel, type StructuredOutputMethodOptions, type ToolDefinition, type BaseLanguageModelCallOptions, type BaseLanguageModelInput, type BaseLanguageModelParams } from \"./base.js\";\nimport { type CallbackManagerForLLMRun, type Callbacks } from \"../callbacks/manager.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport type { BaseCache } from \"../caches/base.js\";\nimport { StructuredToolInterface, StructuredToolParams } from \"../tools/index.js\";\nimport { Runnable, RunnableToolLike } from \"../runnables/base.js\";\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ToolChoice = string | Record<string, any> | \"auto\" | \"any\";\n/**\n * Represents a serialized chat model.\n */\nexport type SerializedChatModel = {\n    _model: string;\n    _type: string;\n} & Record<string, any>;\n// todo?\n/**\n * Represents a serialized large language model.\n */\nexport type SerializedLLM = {\n    _model: string;\n    _type: string;\n} & Record<string, any>;\n/**\n * Represents the parameters for a base chat model.\n */\nexport type BaseChatModelParams = BaseLanguageModelParams & {\n    /**\n     * Whether to disable streaming.\n     *\n     * If streaming is bypassed, then `stream()` will defer to\n     * `invoke()`.\n     *\n     * - If true, will always bypass streaming case.\n     * - If false (default), will always use streaming case if available.\n     */\n    disableStreaming?: boolean;\n    /**\n     * Version of `AIMessage` output format to store in message content.\n     *\n     * `AIMessage.contentBlocks` will lazily parse the contents of `content` into a\n     * standard format. This flag can be used to additionally store the standard format\n     * as the message content, e.g., for serialization purposes.\n     *\n     * - \"v0\": provider-specific format in content (can lazily parse with `.contentBlocks`)\n     * - \"v1\": standardized format in content (consistent with `.contentBlocks`)\n     *\n     * You can also set `LC_OUTPUT_VERSION` as an environment variable to \"v1\" to\n     * enable this by default.\n     *\n     * @default \"v0\"\n     */\n    outputVersion?: MessageOutputVersion;\n};\n/**\n * Represents the call options for a base chat model.\n */\nexport type BaseChatModelCallOptions = BaseLanguageModelCallOptions & {\n    /**\n     * Specifies how the chat model should use tools.\n     * @default undefined\n     *\n     * Possible values:\n     * - \"auto\": The model may choose to use any of the provided tools, or none.\n     * - \"any\": The model must use one of the provided tools.\n     * - \"none\": The model must not use any tools.\n     * - A string (not \"auto\", \"any\", or \"none\"): The name of a specific tool the model must use.\n     * - An object: A custom schema specifying tool choice parameters. Specific to the provider.\n     *\n     * Note: Not all providers support tool_choice. An error will be thrown\n     * if used with an unsupported model.\n     */\n    tool_choice?: ToolChoice;\n    /**\n     * Version of `AIMessage` output format to store in message content.\n     *\n     * `AIMessage.contentBlocks` will lazily parse the contents of `content` into a\n     * standard format. This flag can be used to additionally store the standard format\n     * as the message content, e.g., for serialization purposes.\n     *\n     * - \"v0\": provider-specific format in content (can lazily parse with `.contentBlocks`)\n     * - \"v1\": standardized format in content (consistent with `.contentBlocks`)\n     *\n     * You can also set `LC_OUTPUT_VERSION` as an environment variable to \"v1\" to\n     * enable this by default.\n     *\n     * @default \"v0\"\n     */\n    outputVersion?: MessageOutputVersion;\n};\nexport type LangSmithParams = {\n    ls_provider?: string;\n    ls_model_name?: string;\n    ls_model_type: \"chat\";\n    ls_temperature?: number;\n    ls_max_tokens?: number;\n    ls_stop?: Array<string>;\n};\nexport type BindToolsInput = StructuredToolInterface\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n | Record<string, any> | ToolDefinition | RunnableToolLike | StructuredToolParams;\n/**\n * Base class for chat models. It extends the BaseLanguageModel class and\n * provides methods for generating chat based on input messages.\n */\nexport declare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions, \n// TODO: Fix the parameter order on the next minor version.\nOutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguageModel<OutputMessageType, CallOptions> {\n    // Backwards compatibility since fields have been moved to RunnableConfig\n    ParsedCallOptions: Omit<CallOptions, Exclude<keyof RunnableConfig, \"signal\" | \"timeout\" | \"maxConcurrency\">>;\n    // Only ever instantiated in main LangChain\n    lc_namespace: string[];\n    disableStreaming: boolean;\n    outputVersion?: MessageOutputVersion;\n    get callKeys(): string[];\n    constructor(fields: BaseChatModelParams);\n    _combineLLMOutput?(...llmOutputs: LLMResult[\"llmOutput\"][]): LLMResult[\"llmOutput\"];\n    protected _separateRunnableConfigFromCallOptionsCompat(options?: Partial<CallOptions>): [RunnableConfig, this[\"ParsedCallOptions\"]];\n    /**\n     * Bind tool-like objects to this chat model.\n     *\n     * @param tools A list of tool definitions to bind to this chat model.\n     * Can be a structured tool, an OpenAI formatted tool, or an object\n     * matching the provider's specific tool schema.\n     * @param kwargs Any additional parameters to bind.\n     */\n    bindTools?(tools: BindToolsInput[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, OutputMessageType, CallOptions>;\n    /**\n     * Invokes the chat model with a single input.\n     * @param input The input for the language model.\n     * @param options The call options.\n     * @returns A Promise that resolves to a BaseMessageChunk.\n     */\n    invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<OutputMessageType>;\n    // eslint-disable-next-line require-yield\n    _streamResponseChunks(_messages: BaseMessage[], _options: this[\"ParsedCallOptions\"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;\n    _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<OutputMessageType>;\n    getLsParams(options: this[\"ParsedCallOptions\"]): LangSmithParams;\n    /** @ignore */\n    _generateUncached(messages: BaseMessageLike[][], parsedOptions: this[\"ParsedCallOptions\"], handledOptions: RunnableConfig, startedRunManagers?: CallbackManagerForLLMRun[]): Promise<LLMResult>;\n    _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions }: {\n        messages: BaseMessageLike[][];\n        cache: BaseCache<Generation[]>;\n        llmStringKey: string;\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        parsedOptions: any;\n        handledOptions: RunnableConfig;\n    }): Promise<LLMResult & {\n        missingPromptIndices: number[];\n        startedRunManagers?: CallbackManagerForLLMRun[];\n    }>;\n    /**\n     * Generates chat based on the input messages.\n     * @param messages An array of arrays of BaseMessage instances.\n     * @param options The call options or an array of stop sequences.\n     * @param callbacks The callbacks for the language model.\n     * @returns A Promise that resolves to an LLMResult.\n     */\n    generate(messages: BaseMessageLike[][], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    /**\n     * Get the parameters used to invoke the model\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    invocationParams(_options?: this[\"ParsedCallOptions\"]): any;\n    _modelType(): string;\n    abstract _llmType(): string;\n    /**\n     * Generates a prompt based on the input prompt values.\n     * @param promptValues An array of BasePromptValue instances.\n     * @param options The call options or an array of stop sequences.\n     * @param callbacks The callbacks for the language model.\n     * @returns A Promise that resolves to an LLMResult.\n     */\n    generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    abstract _generate(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n    withStructuredOutput<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV4<RunOutput>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n     | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n    withStructuredOutput<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV4<RunOutput>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n     | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n    withStructuredOutput<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV3<RunOutput>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n     | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n    withStructuredOutput<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV3<RunOutput>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n     | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n}\n/**\n * An abstract class that extends BaseChatModel and provides a simple\n * implementation of _generate.\n */\nexport declare abstract class SimpleChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions> extends BaseChatModel<CallOptions> {\n    abstract _call(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<string>;\n    _generate(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n}\n"],"mappings":"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"}

package/dist/language_models/chat_models.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chat_models.d.ts","names":["ZodType","ZodTypeV3","$ZodType","ZodTypeV4","BaseMessage","BaseMessageChunk","BaseMessageLike","AIMessageChunk","MessageOutputVersion","BasePromptValueInterface","LLMResult","ChatGenerationChunk","ChatResult","Generation","BaseLanguageModel","StructuredOutputMethodOptions","ToolDefinition","BaseLanguageModelCallOptions","BaseLanguageModelInput","BaseLanguageModelParams","CallbackManagerForLLMRun","Callbacks","RunnableConfig","BaseCache","StructuredToolInterface","StructuredToolParams","Runnable","RunnableToolLike","ToolChoice","Record","SerializedChatModel","SerializedLLM","BaseChatModelParams","BaseChatModelCallOptions","LangSmithParams","Array","BindToolsInput","BaseChatModel","OutputMessageType","CallOptions","Exclude","Omit","Partial","Promise","AsyncGenerator","messages","cache","llmStringKey","parsedOptions","handledOptions","RunOutput","SimpleChatModel"],"sources":["../../src/language_models/chat_models.d.ts"],"sourcesContent":["import type { ZodType as ZodTypeV3 } from \"zod/v3\";\nimport type { $ZodType as ZodTypeV4 } from \"zod/v4/core\";\nimport { type BaseMessage, BaseMessageChunk, type BaseMessageLike, AIMessageChunk, MessageOutputVersion } from \"../messages/index.js\";\nimport type { BasePromptValueInterface } from \"../prompt_values.js\";\nimport { LLMResult, ChatGenerationChunk, type ChatResult, type Generation } from \"../outputs.js\";\nimport { BaseLanguageModel, type StructuredOutputMethodOptions, type ToolDefinition, type BaseLanguageModelCallOptions, type BaseLanguageModelInput, type BaseLanguageModelParams } from \"./base.js\";\nimport { type CallbackManagerForLLMRun, type Callbacks } from \"../callbacks/manager.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport type { BaseCache } from \"../caches/base.js\";\nimport { StructuredToolInterface, StructuredToolParams } from \"../tools/index.js\";\nimport { Runnable, RunnableToolLike } from \"../runnables/base.js\";\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ToolChoice = string | Record<string, any> | \"auto\" | \"any\";\n/**\n * Represents a serialized chat model.\n */\nexport type SerializedChatModel = {\n    _model: string;\n    _type: string;\n} & Record<string, any>;\n// todo?\n/**\n * Represents a serialized large language model.\n */\nexport type SerializedLLM = {\n    _model: string;\n    _type: string;\n} & Record<string, any>;\n/**\n * Represents the parameters for a base chat model.\n */\nexport type BaseChatModelParams = BaseLanguageModelParams & {\n    /**\n     * Whether to disable streaming.\n     *\n     * If streaming is bypassed, then `stream()` will defer to\n     * `invoke()`.\n     *\n     * - If true, will always bypass streaming case.\n     * - If false (default), will always use streaming case if available.\n     */\n    disableStreaming?: boolean;\n    /**\n     * Version of `AIMessage` output format to store in message content.\n     *\n     * `AIMessage.contentBlocks` will lazily parse the contents of `content` into a\n     * standard format. This flag can be used to additionally store the standard format\n     * as the message content, e.g., for serialization purposes.\n     *\n     * - \"v0\": provider-specific format in content (can lazily parse with `.contentBlocks`)\n     * - \"v1\": standardized format in content (consistent with `.contentBlocks`)\n     *\n     * You can also set `LC_OUTPUT_VERSION` as an environment variable to \"v1\" to\n     * enable this by default.\n     *\n     * @default \"v0\"\n     */\n    outputVersion?: MessageOutputVersion;\n};\n/**\n * Represents the call options for a base chat model.\n */\nexport type BaseChatModelCallOptions = BaseLanguageModelCallOptions & {\n    /**\n     * Specifies how the chat model should use tools.\n     * @default undefined\n     *\n     * Possible values:\n     * - \"auto\": The model may choose to use any of the provided tools, or none.\n     * - \"any\": The model must use one of the provided tools.\n     * - \"none\": The model must not use any tools.\n     * - A string (not \"auto\", \"any\", or \"none\"): The name of a specific tool the model must use.\n     * - An object: A custom schema specifying tool choice parameters. Specific to the provider.\n     *\n     * Note: Not all providers support tool_choice. An error will be thrown\n     * if used with an unsupported model.\n     */\n    tool_choice?: ToolChoice;\n    /**\n     * Version of `AIMessage` output format to store in message content.\n     *\n     * `AIMessage.contentBlocks` will lazily parse the contents of `content` into a\n     * standard format. This flag can be used to additionally store the standard format\n     * as the message content, e.g., for serialization purposes.\n     *\n     * - \"v0\": provider-specific format in content (can lazily parse with `.contentBlocks`)\n     * - \"v1\": standardized format in content (consistent with `.contentBlocks`)\n     *\n     * You can also set `LC_OUTPUT_VERSION` as an environment variable to \"v1\" to\n     * enable this by default.\n     *\n     * @default \"v0\"\n     */\n    outputVersion?: MessageOutputVersion;\n};\nexport type LangSmithParams = {\n    ls_provider?: string;\n    ls_model_name?: string;\n    ls_model_type: \"chat\";\n    ls_temperature?: number;\n    ls_max_tokens?: number;\n    ls_stop?: Array<string>;\n};\nexport type BindToolsInput = StructuredToolInterface\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n | Record<string, any> | ToolDefinition | RunnableToolLike | StructuredToolParams;\n/**\n * Base class for chat models. It extends the BaseLanguageModel class and\n * provides methods for generating chat based on input messages.\n */\nexport declare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions, \n// TODO: Fix the parameter order on the next minor version.\nOutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguageModel<OutputMessageType, CallOptions> {\n    // Backwards compatibility since fields have been moved to RunnableConfig\n    ParsedCallOptions: Omit<CallOptions, Exclude<keyof RunnableConfig, \"signal\" | \"timeout\" | \"maxConcurrency\">>;\n    // Only ever instantiated in main LangChain\n    lc_namespace: string[];\n    disableStreaming: boolean;\n    outputVersion?: MessageOutputVersion;\n    get callKeys(): string[];\n    constructor(fields: BaseChatModelParams);\n    _combineLLMOutput?(...llmOutputs: LLMResult[\"llmOutput\"][]): LLMResult[\"llmOutput\"];\n    protected _separateRunnableConfigFromCallOptionsCompat(options?: Partial<CallOptions>): [RunnableConfig, this[\"ParsedCallOptions\"]];\n    /**\n     * Bind tool-like objects to this chat model.\n     *\n     * @param tools A list of tool definitions to bind to this chat model.\n     * Can be a structured tool, an OpenAI formatted tool, or an object\n     * matching the provider's specific tool schema.\n     * @param kwargs Any additional parameters to bind.\n     */\n    bindTools?(tools: BindToolsInput[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, OutputMessageType, CallOptions>;\n    /**\n     * Invokes the chat model with a single input.\n     * @param input The input for the language model.\n     * @param options The call options.\n     * @returns A Promise that resolves to a BaseMessageChunk.\n     */\n    invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<OutputMessageType>;\n    // eslint-disable-next-line require-yield\n    _streamResponseChunks(_messages: BaseMessage[], _options: this[\"ParsedCallOptions\"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;\n    _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<OutputMessageType>;\n    getLsParams(options: this[\"ParsedCallOptions\"]): LangSmithParams;\n    /** @ignore */\n    _generateUncached(messages: BaseMessageLike[][], parsedOptions: this[\"ParsedCallOptions\"], handledOptions: RunnableConfig, startedRunManagers?: CallbackManagerForLLMRun[]): Promise<LLMResult>;\n    _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions }: {\n        messages: BaseMessageLike[][];\n        cache: BaseCache<Generation[]>;\n        llmStringKey: string;\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        parsedOptions: any;\n        handledOptions: RunnableConfig;\n    }): Promise<LLMResult & {\n        missingPromptIndices: number[];\n        startedRunManagers?: CallbackManagerForLLMRun[];\n    }>;\n    /**\n     * Generates chat based on the input messages.\n     * @param messages An array of arrays of BaseMessage instances.\n     * @param options The call options or an array of stop sequences.\n     * @param callbacks The callbacks for the language model.\n     * @returns A Promise that resolves to an LLMResult.\n     */\n    generate(messages: BaseMessageLike[][], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    /**\n     * Get the parameters used to invoke the model\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    invocationParams(_options?: this[\"ParsedCallOptions\"]): any;\n    _modelType(): string;\n    abstract _llmType(): string;\n    /**\n     * Generates a prompt based on the input prompt values.\n     * @param promptValues An array of BasePromptValue instances.\n     * @param options The call options or an array of stop sequences.\n     * @param callbacks The callbacks for the language model.\n     * @returns A Promise that resolves to an LLMResult.\n     */\n    generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    abstract _generate(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n    withStructuredOutput<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV4<RunOutput>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n     | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n    withStructuredOutput<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV4<RunOutput>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n     | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n    withStructuredOutput<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV3<RunOutput>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n     | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n    withStructuredOutput<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV3<RunOutput>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n     | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n}\n/**\n * An abstract class that extends BaseChatModel and provides a simple\n * implementation of _generate.\n */\nexport declare abstract class SimpleChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions> extends BaseChatModel<CallOptions> {\n    abstract _call(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<string>;\n    _generate(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n}\n"],"mappings":"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"}

package/dist/language_models/llms.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"llms.d.cts","names":["BasePromptValueInterface","LLMResult","Generation","GenerationChunk","BaseCallbackConfig","CallbackManagerForLLMRun","Callbacks","BaseLanguageModel","BaseLanguageModelCallOptions","BaseLanguageModelInput","BaseLanguageModelParams","RunnableConfig","BaseCache","SerializedLLM","Record","BaseLLMParams","BaseLLMCallOptions","BaseLLM","CallOptions","Exclude","Omit","Promise","AsyncGenerator","Partial","prompts","cache","llmStringKey","parsedOptions","handledOptions","runId","LLM"],"sources":["../../src/language_models/llms.d.ts"],"sourcesContent":["import type { BasePromptValueInterface } from \"../prompt_values.js\";\nimport { type LLMResult, type Generation, GenerationChunk } from \"../outputs.js\";\nimport { type BaseCallbackConfig, type CallbackManagerForLLMRun, type Callbacks } from \"../callbacks/manager.js\";\nimport { BaseLanguageModel, type BaseLanguageModelCallOptions, type BaseLanguageModelInput, type BaseLanguageModelParams } from \"./base.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport type { BaseCache } from \"../caches/base.js\";\nexport type SerializedLLM = {\n    _model: string;\n    _type: string;\n} & Record<string, any>;\nexport interface BaseLLMParams extends BaseLanguageModelParams {\n}\nexport interface BaseLLMCallOptions extends BaseLanguageModelCallOptions {\n}\n/**\n * LLM Wrapper. Takes in a prompt (or prompts) and returns a string.\n */\nexport declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = BaseLLMCallOptions> extends BaseLanguageModel<string, CallOptions> {\n    // Backwards compatibility since fields have been moved to RunnableConfig\n    ParsedCallOptions: Omit<CallOptions, Exclude<keyof RunnableConfig, \"signal\" | \"timeout\" | \"maxConcurrency\">>;\n    // Only ever instantiated in main LangChain\n    lc_namespace: string[];\n    /**\n     * This method takes an input and options, and returns a string. It\n     * converts the input to a prompt value and generates a result based on\n     * the prompt.\n     * @param input Input for the LLM.\n     * @param options Options for the LLM call.\n     * @returns A string result based on the prompt.\n     */\n    invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<string>;\n    // eslint-disable-next-line require-yield\n    _streamResponseChunks(_input: string, _options: this[\"ParsedCallOptions\"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;\n    protected _separateRunnableConfigFromCallOptionsCompat(options?: Partial<CallOptions>): [RunnableConfig, this[\"ParsedCallOptions\"]];\n    _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<string>;\n    /**\n     * This method takes prompt values, options, and callbacks, and generates\n     * a result based on the prompts.\n     * @param promptValues Prompt values for the LLM.\n     * @param options Options for the LLM call.\n     * @param callbacks Callbacks for the LLM call.\n     * @returns An LLMResult based on the prompts.\n     */\n    generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    /**\n     * Run the LLM on the given prompts and input.\n     */\n    abstract _generate(prompts: string[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;\n    /**\n     * Get the parameters used to invoke the model\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    invocationParams(_options?: this[\"ParsedCallOptions\"]): any;\n    _flattenLLMResult(llmResult: LLMResult): LLMResult[];\n    /** @ignore */\n    _generateUncached(prompts: string[], parsedOptions: this[\"ParsedCallOptions\"], handledOptions: BaseCallbackConfig, startedRunManagers?: CallbackManagerForLLMRun[]): Promise<LLMResult>;\n    _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, runId }: {\n        prompts: string[];\n        cache: BaseCache<Generation[]>;\n        llmStringKey: string;\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        parsedOptions: any;\n        handledOptions: RunnableConfig;\n        runId?: string;\n    }): Promise<LLMResult & {\n        missingPromptIndices: number[];\n        startedRunManagers?: CallbackManagerForLLMRun[];\n    }>;\n    /**\n     * Run the LLM on the given prompts and input, handling caching.\n     */\n    generate(prompts: string[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    /**\n     * Get the identifying parameters of the LLM.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    _identifyingParams(): Record<string, any>;\n    /**\n     * Return the string type key uniquely identifying this class of LLM.\n     */\n    abstract _llmType(): string;\n    _modelType(): string;\n}\n/**\n * LLM class that provides a simpler interface to subclass than {@link BaseLLM}.\n *\n * Requires only implementing a simpler {@link _call} method instead of {@link _generate}.\n *\n * @augments BaseLLM\n */\nexport declare abstract class LLM<CallOptions extends BaseLLMCallOptions = BaseLLMCallOptions> extends BaseLLM<CallOptions> {\n    /**\n     * Run the LLM on the given prompt and input.\n     */\n    abstract _call(prompt: string, options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<string>;\n    _generate(prompts: string[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;\n}\n"],"mappings":";;;;;;;;KAMYa,aAAAA;;EAAAA,KAAAA,EAAAA,MAAAA;AAIZ,CAAA,GADIC,MACaC,CAAAA,MAAAA,EAAAA,GAAa,CAAA;AAEbC,UAFAD,aAAAA,SAAsBL,uBAEKF,CAAAA,CAK5C;AAAqC,UALpBQ,kBAAAA,SAA2BR,4BAKP,CAAA;;;;AAEkBG,uBAFzBM,OAEyBN,CAAAA,oBAFGK,kBAEHL,GAFwBK,kBAExBL,CAAAA,SAFoDJ,iBAEpDI,CAAAA,MAAAA,EAF8EO,WAE9EP,CAAAA,CAAAA;EAAc;EAArB,iBAAzBS,EAAAA,IAAAA,CAAKF,WAALE,EAAkBD,OAAlBC,CAAAA,MAAgCT,cAAhCS,EAAAA,QAAAA,GAAAA,SAAAA,GAAAA,gBAAAA,CAAAA,CAAAA;EAAI;EAWa,YAAYF,EAAAA,MAAAA,EAAAA;EAAW;;;;;;;;EAId,MAAYA,CAAAA,KAAAA,EAJ3CT,sBAI2CS,EAAAA,OAAAA,CAAAA,EAJTA,WAISA,CAAAA,EAJKG,OAILH,CAAAA,MAAAA,CAAAA;EAAW;EAAiB,qBASxDlB,CAAAA,MAAAA,EAAAA,MAAAA,EAAAA,QAAAA,EAAAA,IAAAA,CAAAA,mBAAAA,CAAAA,EAAAA,WAAAA,CAAAA,EAX4DK,wBAW5DL,CAAAA,EAXuFsB,cAWvFtB,CAXsGG,eAWtGH,CAAAA;EAAwB,UAAyBkB,4CAAAA,CAAAA,OAAAA,CAAAA,EAVbK,OAUaL,CAVLA,WAUKA,CAAAA,CAAAA,EAAAA,CAVWP,cAUXO,EAAAA,IAAAA,CAAAA,mBAAAA,CAAAA,CAAAA;EAAW,eAAcZ,CAAAA,KAAAA,EAThFG,sBASgFH,EAAAA,OAAAA,CAAAA,EAT9CY,WAS8CZ,CAAAA,EAThCgB,cASgChB,CAAAA,MAAAA,CAAAA;EAAS;;;;;;;;EAYC,cAAuBD,CAAAA,YAAAA,EAZ3GL,wBAY2GK,EAAAA,EAAAA,OAAAA,CAAAA,EAAAA,MAAAA,EAAAA,GAZ1Da,WAY0Db,EAAAA,SAAAA,CAAAA,EAZjCC,SAYiCD,CAAAA,EAZrBgB,OAYqBhB,CAZbJ,SAYaI,CAAAA;EAAwB;;;EACvI,SAAEoB,SAAAA,CAAAA,OAAAA,EAAAA,MAAAA,EAAAA,EAAAA,OAAAA,EAAAA,IAAAA,CAAAA,mBAAAA,CAAAA,EAAAA,UAAAA,CAAAA,EAT4DpB,wBAS5DoB,CAAAA,EATuFJ,OASvFI,CAT+FxB,SAS/FwB,CAAAA;EAAK;;;EAA6C;EAAO,gBAE/DvB,CAAAA,QAAAA,CAAAA,EAAAA,IAAAA,CAAAA,mBAAAA,CAAAA,CAAAA,EAAAA,GAAAA;EAAU,iBAApBU,CAAAA,SAAAA,EALkBX,SAKlBW,CAAAA,EAL8BX,SAK9BW,EAAAA;EAAS;EAIc,iBAEtBX,CAAAA,OAAAA,EAAAA,MAAAA,EAAAA,EAAAA,aAAAA,EAAAA,IAAAA,CAAAA,mBAAAA,CAAAA,EAAAA,cAAAA,EATmFG,kBASnFH,EAAAA,kBAAAA,CAAAA,EAT4HI,wBAS5HJ,EAAAA,CAAAA,EATyJoB,OASzJpB,CATiKA,SASjKA,CAAAA;EAAS,eAEII,CAAAA;IAAAA,OAAAA;IAAAA,KAAAA;IAAAA,YAAAA;IAAAA,aAAAA;IAAAA,cAAAA;IAAAA;EAjD+F,CAiD/FA,EAAAA;IAFrBgB,OAAAA,EAAAA,MAAAA,EAAAA;IAO6CH,KAAAA,EAbtCN,SAasCM,CAb5BhB,UAa4BgB,EAAAA,CAAAA;IAAyBZ,YAAAA,EAAAA,MAAAA;IAAoBL;IAARoB,aAAAA,EAAAA,GAAAA;IAKhEP,cAAAA,EAdFH,cAcEG;IA3DiFP,KAAAA,CAAAA,EAAAA,MAAAA;EAAiB,CAAA,CAAA,EA+CpHc,OA/CoH,CA+C5GpB,SA/C4G,GAAA;IAyE9F6B,oBAAG,EAAA,MAAA,EAAA;IAAA,kBAAA,CAAA,EAxBJzB,wBAwBI,EAAA;EAAA,CAAA,CAAA;EAAuC;;;EAIoC,QAAGgB,CAAAA,OAAAA,EAAAA,MAAAA,EAAAA,EAAAA,OAAAA,CAAAA,EAAAA,MAAAA,EAAAA,GAvB1DH,WAuB0DG,EAAAA,SAAAA,CAAAA,EAvBjCf,SAuBiCe,CAAAA,EAvBrBA,OAuBqBA,CAvBbpB,SAuBaoB,CAAAA;EAAO;;;EACF;EALN,kBAAA,CAAA,CAAA,EAdpFP,MAcoF,CAAA,MAAA,EAAA,GAAA,CAAA;;;;;;;;;;;;;;uBAAhFgB,wBAAwBd,qBAAqBA,4BAA4BC,QAAQC;;;;kFAI3Bb,2BAA2BgB;gFAC7BhB,2BAA2BgB,QAAQpB"}

package/dist/language_models/llms.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"llms.d.ts","names":["BasePromptValueInterface","LLMResult","Generation","GenerationChunk","BaseCallbackConfig","CallbackManagerForLLMRun","Callbacks","BaseLanguageModel","BaseLanguageModelCallOptions","BaseLanguageModelInput","BaseLanguageModelParams","RunnableConfig","BaseCache","SerializedLLM","Record","BaseLLMParams","BaseLLMCallOptions","BaseLLM","CallOptions","Exclude","Omit","Promise","AsyncGenerator","Partial","prompts","cache","llmStringKey","parsedOptions","handledOptions","runId","LLM"],"sources":["../../src/language_models/llms.d.ts"],"sourcesContent":["import type { BasePromptValueInterface } from \"../prompt_values.js\";\nimport { type LLMResult, type Generation, GenerationChunk } from \"../outputs.js\";\nimport { type BaseCallbackConfig, type CallbackManagerForLLMRun, type Callbacks } from \"../callbacks/manager.js\";\nimport { BaseLanguageModel, type BaseLanguageModelCallOptions, type BaseLanguageModelInput, type BaseLanguageModelParams } from \"./base.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport type { BaseCache } from \"../caches/base.js\";\nexport type SerializedLLM = {\n    _model: string;\n    _type: string;\n} & Record<string, any>;\nexport interface BaseLLMParams extends BaseLanguageModelParams {\n}\nexport interface BaseLLMCallOptions extends BaseLanguageModelCallOptions {\n}\n/**\n * LLM Wrapper. Takes in a prompt (or prompts) and returns a string.\n */\nexport declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = BaseLLMCallOptions> extends BaseLanguageModel<string, CallOptions> {\n    // Backwards compatibility since fields have been moved to RunnableConfig\n    ParsedCallOptions: Omit<CallOptions, Exclude<keyof RunnableConfig, \"signal\" | \"timeout\" | \"maxConcurrency\">>;\n    // Only ever instantiated in main LangChain\n    lc_namespace: string[];\n    /**\n     * This method takes an input and options, and returns a string. It\n     * converts the input to a prompt value and generates a result based on\n     * the prompt.\n     * @param input Input for the LLM.\n     * @param options Options for the LLM call.\n     * @returns A string result based on the prompt.\n     */\n    invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<string>;\n    // eslint-disable-next-line require-yield\n    _streamResponseChunks(_input: string, _options: this[\"ParsedCallOptions\"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;\n    protected _separateRunnableConfigFromCallOptionsCompat(options?: Partial<CallOptions>): [RunnableConfig, this[\"ParsedCallOptions\"]];\n    _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<string>;\n    /**\n     * This method takes prompt values, options, and callbacks, and generates\n     * a result based on the prompts.\n     * @param promptValues Prompt values for the LLM.\n     * @param options Options for the LLM call.\n     * @param callbacks Callbacks for the LLM call.\n     * @returns An LLMResult based on the prompts.\n     */\n    generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    /**\n     * Run the LLM on the given prompts and input.\n     */\n    abstract _generate(prompts: string[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;\n    /**\n     * Get the parameters used to invoke the model\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    invocationParams(_options?: this[\"ParsedCallOptions\"]): any;\n    _flattenLLMResult(llmResult: LLMResult): LLMResult[];\n    /** @ignore */\n    _generateUncached(prompts: string[], parsedOptions: this[\"ParsedCallOptions\"], handledOptions: BaseCallbackConfig, startedRunManagers?: CallbackManagerForLLMRun[]): Promise<LLMResult>;\n    _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, runId }: {\n        prompts: string[];\n        cache: BaseCache<Generation[]>;\n        llmStringKey: string;\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        parsedOptions: any;\n        handledOptions: RunnableConfig;\n        runId?: string;\n    }): Promise<LLMResult & {\n        missingPromptIndices: number[];\n        startedRunManagers?: CallbackManagerForLLMRun[];\n    }>;\n    /**\n     * Run the LLM on the given prompts and input, handling caching.\n     */\n    generate(prompts: string[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    /**\n     * Get the identifying parameters of the LLM.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    _identifyingParams(): Record<string, any>;\n    /**\n     * Return the string type key uniquely identifying this class of LLM.\n     */\n    abstract _llmType(): string;\n    _modelType(): string;\n}\n/**\n * LLM class that provides a simpler interface to subclass than {@link BaseLLM}.\n *\n * Requires only implementing a simpler {@link _call} method instead of {@link _generate}.\n *\n * @augments BaseLLM\n */\nexport declare abstract class LLM<CallOptions extends BaseLLMCallOptions = BaseLLMCallOptions> extends BaseLLM<CallOptions> {\n    /**\n     * Run the LLM on the given prompt and input.\n     */\n    abstract _call(prompt: string, options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<string>;\n    _generate(prompts: string[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;\n}\n"],"mappings":"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"}

package/dist/language_models/profile.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"profile.d.cts","names":["ModelProfile"],"sources":["../../src/language_models/profile.d.ts"],"sourcesContent":["/**\n * Represents the capabilities and constraints of a language model.\n *\n * This interface defines the various features and limitations that a model may have,\n * including input/output constraints, multimodal support, and advanced capabilities\n * like tool calling and structured output.\n */\nexport interface ModelProfile {\n    /**\n     * Maximum number of tokens that can be included in the input context window.\n     *\n     * This represents the total token budget for the model's input, including\n     * the prompt, system messages, conversation history, and any other context.\n     *\n     * @example\n     * ```typescript\n     * const profile: ModelProfile = {\n     *   maxInputTokens: 128000 // Model supports up to 128k tokens\n     * };\n     * ```\n     */\n    maxInputTokens?: number;\n    /**\n     * Whether the model supports image inputs.\n     *\n     * When `true`, the model can process images as part of its input, enabling\n     * multimodal interactions where visual content can be analyzed alongside text.\n     *\n     * @see {@link imageUrlInputs} for URL-based image input support\n     */\n    imageInputs?: boolean;\n    /**\n     * Whether the model supports image URL inputs.\n     *\n     * When `true`, the model can accept URLs pointing to images rather than\n     * requiring the image data to be embedded directly in the request. This can\n     * be more efficient for large images or when images are already hosted.\n     *\n     * @see {@link imageInputs} for direct image input support\n     */\n    imageUrlInputs?: boolean;\n    /**\n     * Whether the model supports PDF document inputs.\n     *\n     * When `true`, the model can process PDF files as input, allowing it to\n     * analyze document content, extract information, or answer questions about\n     * PDF documents.\n     */\n    pdfInputs?: boolean;\n    /**\n     * Whether the model supports audio inputs.\n     *\n     * When `true`, the model can process audio data as input, enabling\n     * capabilities like speech recognition, audio analysis, or multimodal\n     * interactions involving sound.\n     */\n    audioInputs?: boolean;\n    /**\n     * Whether the model supports video inputs.\n     *\n     * When `true`, the model can process video data as input, enabling\n     * capabilities like video analysis, scene understanding, or multimodal\n     * interactions involving moving images.\n     */\n    videoInputs?: boolean;\n    /**\n     * Whether the model supports image content in tool messages.\n     *\n     * When `true`, tool responses can include images that the model can process\n     * and reason about. This enables workflows where tools return visual data\n     * that the model needs to interpret.\n     */\n    imageToolMessage?: boolean;\n    /**\n     * Whether the model supports PDF content in tool messages.\n     *\n     * When `true`, tool responses can include PDF documents that the model can\n     * process and reason about. This enables workflows where tools return\n     * document data that the model needs to interpret.\n     */\n    pdfToolMessage?: boolean;\n    /**\n     * Maximum number of tokens the model can generate in its output.\n     *\n     * This represents the upper limit on the length of the model's response.\n     * The actual output may be shorter depending on the completion criteria\n     * (e.g., natural stopping point, stop sequences).\n     *\n     * @example\n     * ```typescript\n     * const profile: ModelProfile = {\n     *   maxOutputTokens: 4096 // Model can generate up to 4k tokens\n     * };\n     * ```\n     */\n    maxOutputTokens?: number;\n    /**\n     * Whether the model supports reasoning or chain-of-thought output.\n     *\n     * When `true`, the model can produce explicit reasoning steps or\n     * chain-of-thought explanations as part of its output. This is useful\n     * for understanding the model's decision-making process and improving\n     * transparency in complex reasoning tasks.\n     */\n    reasoningOutput?: boolean;\n    /**\n     * Whether the model can generate image outputs.\n     *\n     * When `true`, the model can produce images as part of its response,\n     * enabling capabilities like image generation, editing, or visual\n     * content creation.\n     */\n    imageOutputs?: boolean;\n    /**\n     * Whether the model can generate audio outputs.\n     *\n     * When `true`, the model can produce audio data as part of its response,\n     * enabling capabilities like text-to-speech, audio generation, or\n     * sound synthesis.\n     */\n    audioOutputs?: boolean;\n    /**\n     * Whether the model can generate video outputs.\n     *\n     * When `true`, the model can produce video data as part of its response,\n     * enabling capabilities like video generation, editing, or visual\n     * content creation with motion.\n     */\n    videoOutputs?: boolean;\n    /**\n     * Whether the model supports tool calling (function calling).\n     *\n     * When `true`, the model can invoke external tools or functions during\n     * its reasoning process. The model can decide which tools to call,\n     * with what arguments, and can incorporate the tool results into its\n     * final response.\n     *\n     * @see {@link toolChoice} for controlling tool selection behavior\n     * @see {@link https://docs.langchain.com/oss/javascript/langchain/models#tool-calling}\n     */\n    toolCalling?: boolean;\n    /**\n     * Whether the model supports tool choice control.\n     *\n     * When `true`, the caller can specify how the model should select tools,\n     * such as forcing the use of a specific tool, allowing any tool, or\n     * preventing tool use entirely. This provides fine-grained control over\n     * the model's tool-calling behavior.\n     *\n     * @see {@link toolCalling} for basic tool calling support\n     */\n    toolChoice?: boolean;\n    /**\n     * Whether the model supports structured output generation.\n     *\n     * When `true`, the model can generate responses that conform to a\n     * specified schema or structure (e.g., JSON with a particular format).\n     * This is useful for ensuring the model's output can be reliably parsed\n     * and processed programmatically.\n     *\n     * @example\n     * ```typescript\n     * // Model can be instructed to return JSON matching a schema\n     * const profile: ModelProfile = {\n     *   structuredOutput: true\n     * };\n     * ```\n     */\n    structuredOutput?: boolean;\n}\n"],"mappings":";;AAOA;;;;;;UAAiBA,YAAAA"}

package/dist/language_models/profile.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"profile.d.ts","names":["ModelProfile"],"sources":["../../src/language_models/profile.d.ts"],"sourcesContent":["/**\n * Represents the capabilities and constraints of a language model.\n *\n * This interface defines the various features and limitations that a model may have,\n * including input/output constraints, multimodal support, and advanced capabilities\n * like tool calling and structured output.\n */\nexport interface ModelProfile {\n    /**\n     * Maximum number of tokens that can be included in the input context window.\n     *\n     * This represents the total token budget for the model's input, including\n     * the prompt, system messages, conversation history, and any other context.\n     *\n     * @example\n     * ```typescript\n     * const profile: ModelProfile = {\n     *   maxInputTokens: 128000 // Model supports up to 128k tokens\n     * };\n     * ```\n     */\n    maxInputTokens?: number;\n    /**\n     * Whether the model supports image inputs.\n     *\n     * When `true`, the model can process images as part of its input, enabling\n     * multimodal interactions where visual content can be analyzed alongside text.\n     *\n     * @see {@link imageUrlInputs} for URL-based image input support\n     */\n    imageInputs?: boolean;\n    /**\n     * Whether the model supports image URL inputs.\n     *\n     * When `true`, the model can accept URLs pointing to images rather than\n     * requiring the image data to be embedded directly in the request. This can\n     * be more efficient for large images or when images are already hosted.\n     *\n     * @see {@link imageInputs} for direct image input support\n     */\n    imageUrlInputs?: boolean;\n    /**\n     * Whether the model supports PDF document inputs.\n     *\n     * When `true`, the model can process PDF files as input, allowing it to\n     * analyze document content, extract information, or answer questions about\n     * PDF documents.\n     */\n    pdfInputs?: boolean;\n    /**\n     * Whether the model supports audio inputs.\n     *\n     * When `true`, the model can process audio data as input, enabling\n     * capabilities like speech recognition, audio analysis, or multimodal\n     * interactions involving sound.\n     */\n    audioInputs?: boolean;\n    /**\n     * Whether the model supports video inputs.\n     *\n     * When `true`, the model can process video data as input, enabling\n     * capabilities like video analysis, scene understanding, or multimodal\n     * interactions involving moving images.\n     */\n    videoInputs?: boolean;\n    /**\n     * Whether the model supports image content in tool messages.\n     *\n     * When `true`, tool responses can include images that the model can process\n     * and reason about. This enables workflows where tools return visual data\n     * that the model needs to interpret.\n     */\n    imageToolMessage?: boolean;\n    /**\n     * Whether the model supports PDF content in tool messages.\n     *\n     * When `true`, tool responses can include PDF documents that the model can\n     * process and reason about. This enables workflows where tools return\n     * document data that the model needs to interpret.\n     */\n    pdfToolMessage?: boolean;\n    /**\n     * Maximum number of tokens the model can generate in its output.\n     *\n     * This represents the upper limit on the length of the model's response.\n     * The actual output may be shorter depending on the completion criteria\n     * (e.g., natural stopping point, stop sequences).\n     *\n     * @example\n     * ```typescript\n     * const profile: ModelProfile = {\n     *   maxOutputTokens: 4096 // Model can generate up to 4k tokens\n     * };\n     * ```\n     */\n    maxOutputTokens?: number;\n    /**\n     * Whether the model supports reasoning or chain-of-thought output.\n     *\n     * When `true`, the model can produce explicit reasoning steps or\n     * chain-of-thought explanations as part of its output. This is useful\n     * for understanding the model's decision-making process and improving\n     * transparency in complex reasoning tasks.\n     */\n    reasoningOutput?: boolean;\n    /**\n     * Whether the model can generate image outputs.\n     *\n     * When `true`, the model can produce images as part of its response,\n     * enabling capabilities like image generation, editing, or visual\n     * content creation.\n     */\n    imageOutputs?: boolean;\n    /**\n     * Whether the model can generate audio outputs.\n     *\n     * When `true`, the model can produce audio data as part of its response,\n     * enabling capabilities like text-to-speech, audio generation, or\n     * sound synthesis.\n     */\n    audioOutputs?: boolean;\n    /**\n     * Whether the model can generate video outputs.\n     *\n     * When `true`, the model can produce video data as part of its response,\n     * enabling capabilities like video generation, editing, or visual\n     * content creation with motion.\n     */\n    videoOutputs?: boolean;\n    /**\n     * Whether the model supports tool calling (function calling).\n     *\n     * When `true`, the model can invoke external tools or functions during\n     * its reasoning process. The model can decide which tools to call,\n     * with what arguments, and can incorporate the tool results into its\n     * final response.\n     *\n     * @see {@link toolChoice} for controlling tool selection behavior\n     * @see {@link https://docs.langchain.com/oss/javascript/langchain/models#tool-calling}\n     */\n    toolCalling?: boolean;\n    /**\n     * Whether the model supports tool choice control.\n     *\n     * When `true`, the caller can specify how the model should select tools,\n     * such as forcing the use of a specific tool, allowing any tool, or\n     * preventing tool use entirely. This provides fine-grained control over\n     * the model's tool-calling behavior.\n     *\n     * @see {@link toolCalling} for basic tool calling support\n     */\n    toolChoice?: boolean;\n    /**\n     * Whether the model supports structured output generation.\n     *\n     * When `true`, the model can generate responses that conform to a\n     * specified schema or structure (e.g., JSON with a particular format).\n     * This is useful for ensuring the model's output can be reliably parsed\n     * and processed programmatically.\n     *\n     * @example\n     * ```typescript\n     * // Model can be instructed to return JSON matching a schema\n     * const profile: ModelProfile = {\n     *   structuredOutput: true\n     * };\n     * ```\n     */\n    structuredOutput?: boolean;\n}\n"],"mappings":";;AAOA;;;;;;UAAiBA,YAAAA"}

package/dist/load/import_type.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"import_type.d.cts","names":["OptionalImportMap","SecretMap"],"sources":["../../src/load/import_type.d.ts"],"sourcesContent":["// Auto-generated by lc-secrets plugin. Do not edit manually.\nexport interface OptionalImportMap {\n}\nexport interface SecretMap {\n}\n"],"mappings":";;AACiBA,UAAAA,iBAAAA,CAAiB,CAElC;UAAiBC,SAAAA"}

package/dist/load/import_type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"import_type.d.ts","names":["OptionalImportMap","SecretMap"],"sources":["../../src/load/import_type.d.ts"],"sourcesContent":["// Auto-generated by lc-secrets plugin. Do not edit manually.\nexport interface OptionalImportMap {\n}\nexport interface SecretMap {\n}\n"],"mappings":";;AACiBA,UAAAA,iBAAAA,CAAiB,CAElC;UAAiBC,SAAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","names":["OptionalImportMap","SecretMap","load","Record","T","Promise"],"sources":["../../src/load/index.d.ts"],"sourcesContent":["import type { OptionalImportMap, SecretMap } from \"./import_type.js\";\nexport declare function load<T>(text: string, mappings?: {\n    secretsMap?: SecretMap;\n    optionalImportsMap?: OptionalImportMap;\n    optionalImportEntrypoints?: string[];\n    importMap?: Record<string, unknown>;\n}): Promise<T>;\n"],"mappings":";;;iBACwBE,8BACE;eAATD;EADOC,kBAAI,CAAA,EAEHF,iBAFG;EAAA,yBAAA,CAAA,EAAA,MAAA,EAAA;EAAA,SACXC,CAAAA,EAGDE,MAHCF,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;CAAS,CAAA,EAItBI,OAHqBL,CAGbI,CAHaJ,CAAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":["OptionalImportMap","SecretMap","load","Record","T","Promise"],"sources":["../../src/load/index.d.ts"],"sourcesContent":["import type { OptionalImportMap, SecretMap } from \"./import_type.js\";\nexport declare function load<T>(text: string, mappings?: {\n    secretsMap?: SecretMap;\n    optionalImportsMap?: OptionalImportMap;\n    optionalImportEntrypoints?: string[];\n    importMap?: Record<string, unknown>;\n}): Promise<T>;\n"],"mappings":";;;iBACwBE,8BACE;eAATD;EADOC,kBAAI,CAAA,EAEHF,iBAFG;EAAA,yBAAA,CAAA,EAAA,MAAA,EAAA;EAAA,SACXC,CAAAA,EAGDE,MAHCF,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;CAAS,CAAA,EAItBI,OAHqBL,CAGbI,CAHaJ,CAAAA"}

package/dist/load/map_keys.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"map_keys.d.cts","names":["SerializedFields","SerializedKeyAlias","keyToJson","keyFromJson","mapKeys"],"sources":["../../src/load/map_keys.d.ts"],"sourcesContent":["export interface SerializedFields {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    [key: string]: any;\n}\nexport interface SerializedKeyAlias {\n    [key: string]: string;\n}\nexport declare function keyToJson(key: string, map?: SerializedKeyAlias): string;\nexport declare function keyFromJson(key: string, map?: SerializedKeyAlias): string;\nexport declare function mapKeys(fields: SerializedFields, mapper: typeof keyToJson, map?: SerializedKeyAlias): SerializedFields;\n"],"mappings":";UAAiBA,gBAAAA;EAAAA"}

package/dist/load/map_keys.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"map_keys.d.ts","names":["SerializedFields","SerializedKeyAlias","keyToJson","keyFromJson","mapKeys"],"sources":["../../src/load/map_keys.d.ts"],"sourcesContent":["export interface SerializedFields {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    [key: string]: any;\n}\nexport interface SerializedKeyAlias {\n    [key: string]: string;\n}\nexport declare function keyToJson(key: string, map?: SerializedKeyAlias): string;\nexport declare function keyFromJson(key: string, map?: SerializedKeyAlias): string;\nexport declare function mapKeys(fields: SerializedFields, mapper: typeof keyToJson, map?: SerializedKeyAlias): SerializedFields;\n"],"mappings":";UAAiBA,gBAAAA;EAAAA"}

package/dist/load/serializable.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serializable.d.cts","names":["SerializedFields","BaseSerialized","T","Record","SerializedConstructor","SerializedSecret","SerializedNotImplemented","Serialized","get_lc_unique_name","Serializable","SerializableInterface"],"sources":["../../src/load/serializable.d.ts"],"sourcesContent":["import { type SerializedFields } from \"./map_keys.js\";\nexport interface BaseSerialized<T extends string> {\n    lc: number;\n    type: T;\n    id: string[];\n    name?: string;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    graph?: Record<string, any>;\n}\nexport interface SerializedConstructor extends BaseSerialized<\"constructor\"> {\n    kwargs: SerializedFields;\n}\nexport interface SerializedSecret extends BaseSerialized<\"secret\"> {\n}\nexport interface SerializedNotImplemented extends BaseSerialized<\"not_implemented\"> {\n}\nexport type Serialized = SerializedConstructor | SerializedSecret | SerializedNotImplemented;\n/**\n * Get a unique name for the module, rather than parent class implementations.\n * Should not be subclassed, subclass lc_name above instead.\n */\nexport declare function get_lc_unique_name(serializableClass: typeof Serializable): string;\nexport interface SerializableInterface {\n    get lc_id(): string[];\n}\nexport declare abstract class Serializable implements SerializableInterface {\n    lc_serializable: boolean;\n    lc_kwargs: SerializedFields;\n    /**\n     * A path to the module that contains the class, eg. [\"langchain\", \"llms\"]\n     * Usually should be the same as the entrypoint the class is exported from.\n     */\n    abstract lc_namespace: string[];\n    /**\n     * The name of the serializable. Override to provide an alias or\n     * to preserve the serialized module name in minified environments.\n     *\n     * Implemented as a static method to support loading logic.\n     */\n    static lc_name(): string;\n    /**\n     * The final serialized identifier for the module.\n     */\n    get lc_id(): string[];\n    /**\n     * A map of secrets, which will be omitted from serialization.\n     * Keys are paths to the secret in constructor args, e.g. \"foo.bar.baz\".\n     * Values are the secret ids, which will be used when deserializing.\n     */\n    get lc_secrets(): {\n        [key: string]: string;\n    } | undefined;\n    /**\n     * A map of additional attributes to merge with constructor args.\n     * Keys are the attribute names, e.g. \"foo\".\n     * Values are the attribute values, which will be serialized.\n     * These attributes need to be accepted by the constructor as arguments.\n     */\n    get lc_attributes(): SerializedFields | undefined;\n    /**\n     * A map of aliases for constructor args.\n     * Keys are the attribute names, e.g. \"foo\".\n     * Values are the alias that will replace the key in serialization.\n     * This is used to eg. make argument names match Python.\n     */\n    get lc_aliases(): {\n        [key: string]: string;\n    } | undefined;\n    /**\n     * A manual list of keys that should be serialized.\n     * If not overridden, all fields passed into the constructor will be serialized.\n     */\n    get lc_serializable_keys(): string[] | undefined;\n    constructor(kwargs?: SerializedFields, ..._args: never[]);\n    toJSON(): Serialized;\n    toJSONNotImplemented(): SerializedNotImplemented;\n}\n"],"mappings":";;;UACiBC;;EAAAA,IAAAA,EAEPC,CAFOD;EAAc,EAAA,EAAA,MAAA,EAAA;EAAA,IAErBC,CAAAA,EAAAA,MAAAA;EAAC;EAIO,KAAA,CAAA,EAANC,MAAM,CAAA,MAAA,EAAA,GAAA,CAAA;AAElB;AAAsC,UAArBC,qBAAAA,SAA8BH,cAAT,CAAA,aAAA,CAAA,CAAA;EAAA,MAC1BD,EAAAA,gBAAAA;;AADiD,UAG5CK,gBAAAA,SAAyBJ,cAHmB,CAAA,QAAA,CAAA,CAAA,CAG7D;AAEiBK,UAAAA,wBAAAA,SAAiCL,cAAc,CAAA,iBAAA,CAAA,CAAA,CAEhE;AAAsB,KAAVM,UAAAA,GAAaH,qBAAH,GAA2BC,gBAA3B,GAA8CC,wBAA9C;;;;AAAsE;AAKpEE,iBAAAA,kBAAAA,CAA6CC,iBAAY,EAAA,OAAZA,YAAY,CAAA,EAAA,MAAA;AAChEC,UAAAA,qBAAAA,CAAqB;EAGRD,IAAAA,KAAAA,EAAAA,EAAAA,MAAY,EAAA;;AAE3BT,uBAFeS,YAAAA,YAAwBC,qBAEvCV,CAAAA;EAAgB,eA+BNA,EAAAA,OAAAA;EAAgB,SAehBA,EA9CVA,gBA8CUA;EAAgB;;;AAhDkC;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAiClDA;;;;;;;;;;;;;;;uBAeAA;YACXO;0BACcD"}

package/dist/load/serializable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serializable.d.ts","names":["SerializedFields","BaseSerialized","T","Record","SerializedConstructor","SerializedSecret","SerializedNotImplemented","Serialized","get_lc_unique_name","Serializable","SerializableInterface"],"sources":["../../src/load/serializable.d.ts"],"sourcesContent":["import { type SerializedFields } from \"./map_keys.js\";\nexport interface BaseSerialized<T extends string> {\n    lc: number;\n    type: T;\n    id: string[];\n    name?: string;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    graph?: Record<string, any>;\n}\nexport interface SerializedConstructor extends BaseSerialized<\"constructor\"> {\n    kwargs: SerializedFields;\n}\nexport interface SerializedSecret extends BaseSerialized<\"secret\"> {\n}\nexport interface SerializedNotImplemented extends BaseSerialized<\"not_implemented\"> {\n}\nexport type Serialized = SerializedConstructor | SerializedSecret | SerializedNotImplemented;\n/**\n * Get a unique name for the module, rather than parent class implementations.\n * Should not be subclassed, subclass lc_name above instead.\n */\nexport declare function get_lc_unique_name(serializableClass: typeof Serializable): string;\nexport interface SerializableInterface {\n    get lc_id(): string[];\n}\nexport declare abstract class Serializable implements SerializableInterface {\n    lc_serializable: boolean;\n    lc_kwargs: SerializedFields;\n    /**\n     * A path to the module that contains the class, eg. [\"langchain\", \"llms\"]\n     * Usually should be the same as the entrypoint the class is exported from.\n     */\n    abstract lc_namespace: string[];\n    /**\n     * The name of the serializable. Override to provide an alias or\n     * to preserve the serialized module name in minified environments.\n     *\n     * Implemented as a static method to support loading logic.\n     */\n    static lc_name(): string;\n    /**\n     * The final serialized identifier for the module.\n     */\n    get lc_id(): string[];\n    /**\n     * A map of secrets, which will be omitted from serialization.\n     * Keys are paths to the secret in constructor args, e.g. \"foo.bar.baz\".\n     * Values are the secret ids, which will be used when deserializing.\n     */\n    get lc_secrets(): {\n        [key: string]: string;\n    } | undefined;\n    /**\n     * A map of additional attributes to merge with constructor args.\n     * Keys are the attribute names, e.g. \"foo\".\n     * Values are the attribute values, which will be serialized.\n     * These attributes need to be accepted by the constructor as arguments.\n     */\n    get lc_attributes(): SerializedFields | undefined;\n    /**\n     * A map of aliases for constructor args.\n     * Keys are the attribute names, e.g. \"foo\".\n     * Values are the alias that will replace the key in serialization.\n     * This is used to eg. make argument names match Python.\n     */\n    get lc_aliases(): {\n        [key: string]: string;\n    } | undefined;\n    /**\n     * A manual list of keys that should be serialized.\n     * If not overridden, all fields passed into the constructor will be serialized.\n     */\n    get lc_serializable_keys(): string[] | undefined;\n    constructor(kwargs?: SerializedFields, ..._args: never[]);\n    toJSON(): Serialized;\n    toJSONNotImplemented(): SerializedNotImplemented;\n}\n"],"mappings":";;;UACiBC;;EAAAA,IAAAA,EAEPC,CAFOD;EAAc,EAAA,EAAA,MAAA,EAAA;EAAA,IAErBC,CAAAA,EAAAA,MAAAA;EAAC;EAIO,KAAA,CAAA,EAANC,MAAM,CAAA,MAAA,EAAA,GAAA,CAAA;AAElB;AAAsC,UAArBC,qBAAAA,SAA8BH,cAAT,CAAA,aAAA,CAAA,CAAA;EAAA,MAC1BD,EAAAA,gBAAAA;;AADiD,UAG5CK,gBAAAA,SAAyBJ,cAHmB,CAAA,QAAA,CAAA,CAAA,CAG7D;AAEiBK,UAAAA,wBAAAA,SAAiCL,cAAc,CAAA,iBAAA,CAAA,CAAA,CAEhE;AAAsB,KAAVM,UAAAA,GAAaH,qBAAH,GAA2BC,gBAA3B,GAA8CC,wBAA9C;;;;AAAsE;AAKpEE,iBAAAA,kBAAAA,CAA6CC,iBAAY,EAAA,OAAZA,YAAY,CAAA,EAAA,MAAA;AAChEC,UAAAA,qBAAAA,CAAqB;EAGRD,IAAAA,KAAAA,EAAAA,EAAAA,MAAY,EAAA;;AAE3BT,uBAFeS,YAAAA,YAAwBC,qBAEvCV,CAAAA;EAAgB,eA+BNA,EAAAA,OAAAA;EAAgB,SAehBA,EA9CVA,gBA8CUA;EAAgB;;;AAhDkC;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAiClDA;;;;;;;;;;;;;;;uBAeAA;YACXO;0BACcD"}

package/dist/memory.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memory.d.cts","names":["InputValues","Record","OutputValues","MemoryVariables","BaseMemory","Promise","getInputValue","getOutputValue","getPromptInputKey"],"sources":["../src/memory.d.ts"],"sourcesContent":["/**\n * Type alias for a record where the keys are strings and the values can\n * be any type. This is used to represent the input values for a Chain.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type InputValues = Record<string, any>;\n/**\n * Type alias for a record where the keys are strings and the values can\n * be any type. This is used to represent the output values from a Chain.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type OutputValues = Record<string, any>;\n/**\n * Type alias for a record where the keys are strings and the values can\n * be any type. This is used to represent the memory variables in a Chain.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type MemoryVariables = Record<string, any>;\n/**\n * Abstract base class for memory in LangChain's Chains. Memory refers to\n * the state in Chains. It can be used to store information about past\n * executions of a Chain and inject that information into the inputs of\n * future executions of the Chain.\n */\nexport declare abstract class BaseMemory {\n    abstract get memoryKeys(): string[];\n    /**\n     * Abstract method that should take an object of input values and return a\n     * Promise that resolves with an object of memory variables. The\n     * implementation of this method should load the memory variables from the\n     * provided input values.\n     * @param values An object of input values.\n     * @returns Promise that resolves with an object of memory variables.\n     */\n    abstract loadMemoryVariables(values: InputValues): Promise<MemoryVariables>;\n    /**\n     * Abstract method that should take two objects, one of input values and\n     * one of output values, and return a Promise that resolves when the\n     * context has been saved. The implementation of this method should save\n     * the context based on the provided input and output values.\n     * @param inputValues An object of input values.\n     * @param outputValues An object of output values.\n     * @returns Promise that resolves when the context has been saved.\n     */\n    abstract saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n}\n/**\n * This function is used by memory classes to select the input value\n * to use for the memory. If there is only one input value, it is used.\n * If there are multiple input values, the inputKey must be specified.\n */\nexport declare const getInputValue: (inputValues: InputValues, inputKey?: string | undefined) => any;\n/**\n * This function is used by memory classes to select the output value\n * to use for the memory. If there is only one output value, it is used.\n * If there are multiple output values, the outputKey must be specified.\n * If no outputKey is specified, an error is thrown.\n */\nexport declare const getOutputValue: (outputValues: OutputValues, outputKey?: string | undefined) => any;\n/**\n * Function used by memory classes to get the key of the prompt input,\n * excluding any keys that are memory variables or the \"stop\" key. If\n * there is not exactly one prompt input key, an error is thrown.\n */\nexport declare function getPromptInputKey(inputs: Record<string, unknown>, memoryVariables: string[]): string;\n"],"mappings":";;AAKA;AAMA;AAMA;AAOA;AAAwC,KAnB5BA,WAAAA,GAAcC,MAmBc,CAAA,MAAA,EAAA,GAAA,CAAA;;;;;;AAoBwCI,KAjCpEH,YAAAA,GAAeD,MAiCqDI,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;AAAO;AAOvF;AAOA;AAMA;;KA/CYF,eAAAA,GAAkBF;;;;;;;uBAOAG,UAAAA;;;;;;;;;;uCAUWJ,cAAcK,QAAQF;;;;;;;;;;oCAUzBH,2BAA2BE,eAAeG;;;;;;;cAO3DC,6BAA6BN;;;;;;;cAO7BO,+BAA+BL;;;;;;iBAM5BM,iBAAAA,SAA0BP"}

package/dist/memory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memory.d.ts","names":["InputValues","Record","OutputValues","MemoryVariables","BaseMemory","Promise","getInputValue","getOutputValue","getPromptInputKey"],"sources":["../src/memory.d.ts"],"sourcesContent":["/**\n * Type alias for a record where the keys are strings and the values can\n * be any type. This is used to represent the input values for a Chain.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type InputValues = Record<string, any>;\n/**\n * Type alias for a record where the keys are strings and the values can\n * be any type. This is used to represent the output values from a Chain.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type OutputValues = Record<string, any>;\n/**\n * Type alias for a record where the keys are strings and the values can\n * be any type. This is used to represent the memory variables in a Chain.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type MemoryVariables = Record<string, any>;\n/**\n * Abstract base class for memory in LangChain's Chains. Memory refers to\n * the state in Chains. It can be used to store information about past\n * executions of a Chain and inject that information into the inputs of\n * future executions of the Chain.\n */\nexport declare abstract class BaseMemory {\n    abstract get memoryKeys(): string[];\n    /**\n     * Abstract method that should take an object of input values and return a\n     * Promise that resolves with an object of memory variables. The\n     * implementation of this method should load the memory variables from the\n     * provided input values.\n     * @param values An object of input values.\n     * @returns Promise that resolves with an object of memory variables.\n     */\n    abstract loadMemoryVariables(values: InputValues): Promise<MemoryVariables>;\n    /**\n     * Abstract method that should take two objects, one of input values and\n     * one of output values, and return a Promise that resolves when the\n     * context has been saved. The implementation of this method should save\n     * the context based on the provided input and output values.\n     * @param inputValues An object of input values.\n     * @param outputValues An object of output values.\n     * @returns Promise that resolves when the context has been saved.\n     */\n    abstract saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n}\n/**\n * This function is used by memory classes to select the input value\n * to use for the memory. If there is only one input value, it is used.\n * If there are multiple input values, the inputKey must be specified.\n */\nexport declare const getInputValue: (inputValues: InputValues, inputKey?: string | undefined) => any;\n/**\n * This function is used by memory classes to select the output value\n * to use for the memory. If there is only one output value, it is used.\n * If there are multiple output values, the outputKey must be specified.\n * If no outputKey is specified, an error is thrown.\n */\nexport declare const getOutputValue: (outputValues: OutputValues, outputKey?: string | undefined) => any;\n/**\n * Function used by memory classes to get the key of the prompt input,\n * excluding any keys that are memory variables or the \"stop\" key. If\n * there is not exactly one prompt input key, an error is thrown.\n */\nexport declare function getPromptInputKey(inputs: Record<string, unknown>, memoryVariables: string[]): string;\n"],"mappings":";;AAKA;AAMA;AAMA;AAOA;AAAwC,KAnB5BA,WAAAA,GAAcC,MAmBc,CAAA,MAAA,EAAA,GAAA,CAAA;;;;;;AAoBwCI,KAjCpEH,YAAAA,GAAeD,MAiCqDI,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;AAAO;AAOvF;AAOA;AAMA;;KA/CYF,eAAAA,GAAkBF;;;;;;;uBAOAG,UAAAA;;;;;;;;;;uCAUWJ,cAAcK,QAAQF;;;;;;;;;;oCAUzBH,2BAA2BE,eAAeG;;;;;;;cAO3DC,6BAA6BN;;;;;;;cAO7BO,+BAA+BL;;;;;;iBAM5BM,iBAAAA,SAA0BP"}

package/dist/messages/ai.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ai.d.cts","names":["BaseMessage","BaseMessageChunk","BaseMessageFields","ContentBlock","$InferMessageContent","$InferMessageProperty","MessageStructure","InvalidToolCall","ToolCall","ToolCallChunk","AIMessageFields","TStructure","AIMessage","Record","Standard","Array","isAIMessage","isAIMessageChunk","AIMessageChunk","AIMessageChunkFields"],"sources":["../../src/messages/ai.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageChunk, BaseMessageFields } from \"./base.js\";\nimport { ContentBlock } from \"./content/index.js\";\nimport { $InferMessageContent, $InferMessageProperty, MessageStructure } from \"./message.js\";\nimport { InvalidToolCall, ToolCall, ToolCallChunk } from \"./tool.js\";\nexport interface AIMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, \"ai\"> {\n    tool_calls?: ToolCall[];\n    invalid_tool_calls?: InvalidToolCall[];\n    usage_metadata?: $InferMessageProperty<TStructure, \"ai\", \"usage_metadata\">;\n}\nexport declare class AIMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, \"ai\"> implements AIMessageFields<TStructure> {\n    readonly type: \"ai\";\n    tool_calls?: ToolCall[];\n    invalid_tool_calls?: InvalidToolCall[];\n    usage_metadata?: AIMessageFields<TStructure>[\"usage_metadata\"];\n    get lc_aliases(): Record<string, string>;\n    constructor(fields: $InferMessageContent<TStructure, \"ai\"> | AIMessageFields<TStructure>);\n    static lc_name(): string;\n    get contentBlocks(): Array<ContentBlock.Standard>;\n    get _printableFields(): Record<string, unknown>;\n    static isInstance(obj: unknown): obj is AIMessage;\n}\n/**\n * @deprecated Use {@link AIMessage.isInstance} instead\n */\nexport declare function isAIMessage<TStructure extends MessageStructure>(x: BaseMessage): x is AIMessage<TStructure>;\n/**\n * @deprecated Use {@link AIMessageChunk.isInstance} instead\n */\nexport declare function isAIMessageChunk<TStructure extends MessageStructure>(x: BaseMessageChunk): x is AIMessageChunk<TStructure>;\nexport type AIMessageChunkFields<TStructure extends MessageStructure = MessageStructure> = AIMessageFields<TStructure> & {\n    tool_call_chunks?: ToolCallChunk[];\n};\n/**\n * Represents a chunk of an AI message, which can be concatenated with\n * other AI message chunks.\n */\nexport declare class AIMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, \"ai\"> implements AIMessage<TStructure>, AIMessageChunkFields<TStructure> {\n    readonly type: \"ai\";\n    tool_calls?: ToolCall[];\n    invalid_tool_calls?: InvalidToolCall[];\n    tool_call_chunks?: ToolCallChunk[];\n    usage_metadata?: AIMessageChunkFields<TStructure>[\"usage_metadata\"];\n    constructor(fields: $InferMessageContent<TStructure, \"ai\"> | AIMessageChunkFields<TStructure>);\n    get lc_aliases(): Record<string, string>;\n    static lc_name(): string;\n    get contentBlocks(): Array<ContentBlock.Standard>;\n    get _printableFields(): Record<string, unknown>;\n    concat(chunk: AIMessageChunk<TStructure>): this;\n    static isInstance(obj: unknown): obj is AIMessageChunk;\n}\n"],"mappings":"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"}

package/dist/messages/ai.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ai.d.ts","names":["BaseMessage","BaseMessageChunk","BaseMessageFields","ContentBlock","$InferMessageContent","$InferMessageProperty","MessageStructure","InvalidToolCall","ToolCall","ToolCallChunk","AIMessageFields","TStructure","AIMessage","Record","Standard","Array","isAIMessage","isAIMessageChunk","AIMessageChunk","AIMessageChunkFields"],"sources":["../../src/messages/ai.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageChunk, BaseMessageFields } from \"./base.js\";\nimport { ContentBlock } from \"./content/index.js\";\nimport { $InferMessageContent, $InferMessageProperty, MessageStructure } from \"./message.js\";\nimport { InvalidToolCall, ToolCall, ToolCallChunk } from \"./tool.js\";\nexport interface AIMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, \"ai\"> {\n    tool_calls?: ToolCall[];\n    invalid_tool_calls?: InvalidToolCall[];\n    usage_metadata?: $InferMessageProperty<TStructure, \"ai\", \"usage_metadata\">;\n}\nexport declare class AIMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, \"ai\"> implements AIMessageFields<TStructure> {\n    readonly type: \"ai\";\n    tool_calls?: ToolCall[];\n    invalid_tool_calls?: InvalidToolCall[];\n    usage_metadata?: AIMessageFields<TStructure>[\"usage_metadata\"];\n    get lc_aliases(): Record<string, string>;\n    constructor(fields: $InferMessageContent<TStructure, \"ai\"> | AIMessageFields<TStructure>);\n    static lc_name(): string;\n    get contentBlocks(): Array<ContentBlock.Standard>;\n    get _printableFields(): Record<string, unknown>;\n    static isInstance(obj: unknown): obj is AIMessage;\n}\n/**\n * @deprecated Use {@link AIMessage.isInstance} instead\n */\nexport declare function isAIMessage<TStructure extends MessageStructure>(x: BaseMessage): x is AIMessage<TStructure>;\n/**\n * @deprecated Use {@link AIMessageChunk.isInstance} instead\n */\nexport declare function isAIMessageChunk<TStructure extends MessageStructure>(x: BaseMessageChunk): x is AIMessageChunk<TStructure>;\nexport type AIMessageChunkFields<TStructure extends MessageStructure = MessageStructure> = AIMessageFields<TStructure> & {\n    tool_call_chunks?: ToolCallChunk[];\n};\n/**\n * Represents a chunk of an AI message, which can be concatenated with\n * other AI message chunks.\n */\nexport declare class AIMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, \"ai\"> implements AIMessage<TStructure>, AIMessageChunkFields<TStructure> {\n    readonly type: \"ai\";\n    tool_calls?: ToolCall[];\n    invalid_tool_calls?: InvalidToolCall[];\n    tool_call_chunks?: ToolCallChunk[];\n    usage_metadata?: AIMessageChunkFields<TStructure>[\"usage_metadata\"];\n    constructor(fields: $InferMessageContent<TStructure, \"ai\"> | AIMessageChunkFields<TStructure>);\n    get lc_aliases(): Record<string, string>;\n    static lc_name(): string;\n    get contentBlocks(): Array<ContentBlock.Standard>;\n    get _printableFields(): Record<string, unknown>;\n    concat(chunk: AIMessageChunk<TStructure>): this;\n    static isInstance(obj: unknown): obj is AIMessageChunk;\n}\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.cts","names":["Serializable","SerializedConstructor","ContentBlock","$InferMessageContent","$InferResponseMetadata","MessageStructure","MessageType","Message","MessageStringFormat","MESSAGE_SYMBOL","StoredMessageData","Record","StoredMessage","StoredGeneration","StoredMessageV1","MessageContent","Array","FunctionCall","BaseMessageFields","TStructure","TRole","Standard","OpenAIToolCall","Partial","mergeContent","_mergeStatus","BaseMessage","NonNullable","Symbol","toStringTag","isOpenAIToolCallArray","_mergeDicts","_mergeLists","Content","_mergeObj","T","BaseMessageChunk","MessageFieldWithRole","_isMessageFieldWithRole","BaseMessageLike","isBaseMessage","isBaseMessageChunk"],"sources":["../../src/messages/base.d.ts"],"sourcesContent":["import { Serializable, SerializedConstructor } from \"../load/serializable.js\";\nimport { ContentBlock } from \"./content/index.js\";\nimport { $InferMessageContent, $InferResponseMetadata, MessageStructure, MessageType, Message } from \"./message.js\";\nimport { type MessageStringFormat } from \"./format.js\";\n/** @internal */\ndeclare const MESSAGE_SYMBOL: unique symbol;\nexport interface StoredMessageData {\n    content: string;\n    role: string | undefined;\n    name: string | undefined;\n    tool_call_id: string | undefined;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    additional_kwargs?: Record<string, any>;\n    /** Response metadata. For example: response headers, logprobs, token counts, model name. */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    response_metadata?: Record<string, any>;\n    id?: string;\n}\nexport interface StoredMessage {\n    type: string;\n    data: StoredMessageData;\n}\nexport interface StoredGeneration {\n    text: string;\n    message?: StoredMessage;\n}\nexport interface StoredMessageV1 {\n    type: string;\n    role: string | undefined;\n    text: string;\n}\nexport type MessageContent = string | Array<ContentBlock>;\nexport interface FunctionCall {\n    /**\n     * The arguments to call the function with, as generated by the model in JSON\n     * format. Note that the model does not always generate valid JSON, and may\n     * hallucinate parameters not defined by your function schema. Validate the\n     * arguments in your code before calling your function.\n     */\n    arguments: string;\n    /**\n     * The name of the function to call.\n     */\n    name: string;\n}\nexport type BaseMessageFields<TStructure extends MessageStructure = MessageStructure, TRole extends MessageType = MessageType> = {\n    id?: string;\n    name?: string;\n    content?: $InferMessageContent<TStructure, TRole>;\n    contentBlocks?: Array<ContentBlock.Standard>;\n    /** @deprecated */\n    additional_kwargs?: {\n        /**\n         * @deprecated Use \"tool_calls\" field on AIMessages instead\n         */\n        function_call?: FunctionCall;\n        /**\n         * @deprecated Use \"tool_calls\" field on AIMessages instead\n         */\n        tool_calls?: OpenAIToolCall[];\n        [key: string]: unknown;\n    };\n    response_metadata?: Partial<$InferResponseMetadata<TStructure, TRole>>;\n};\nexport declare function mergeContent(firstContent: MessageContent, secondContent: MessageContent): MessageContent;\n/**\n * 'Merge' two statuses. If either value passed is 'error', it will return 'error'. Else\n * it will return 'success'.\n *\n * @param {\"success\" | \"error\" | undefined} left The existing value to 'merge' with the new value.\n * @param {\"success\" | \"error\" | undefined} right The new value to 'merge' with the existing value\n * @returns {\"success\" | \"error\"} The 'merged' value.\n */\nexport declare function _mergeStatus(left?: \"success\" | \"error\", right?: \"success\" | \"error\"): \"success\" | \"error\" | undefined;\n/**\n * Base class for all types of messages in a conversation. It includes\n * properties like `content`, `name`, and `additional_kwargs`. It also\n * includes methods like `toDict()` and `_getType()`.\n */\nexport declare abstract class BaseMessage<TStructure extends MessageStructure = MessageStructure, TRole extends MessageType = MessageType> extends Serializable implements Message<TStructure, TRole> {\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    get lc_aliases(): Record<string, string>;\n    readonly [MESSAGE_SYMBOL]: true;\n    abstract readonly type: TRole;\n    id?: string;\n    name?: string;\n    content: $InferMessageContent<TStructure, TRole>;\n    additional_kwargs: NonNullable<BaseMessageFields<TStructure, TRole>[\"additional_kwargs\"]>;\n    response_metadata: NonNullable<BaseMessageFields<TStructure, TRole>[\"response_metadata\"]>;\n    /**\n     * @deprecated Use .getType() instead or import the proper typeguard.\n     * For example:\n     *\n     * ```ts\n     * import { isAIMessage } from \"@langchain/core/messages\";\n     *\n     * const message = new AIMessage(\"Hello!\");\n     * isAIMessage(message); // true\n     * ```\n     */\n    _getType(): MessageType;\n    /**\n     * @deprecated Use .type instead\n     * The type of the message.\n     */\n    getType(): MessageType;\n    constructor(arg: $InferMessageContent<TStructure, TRole> | BaseMessageFields<TStructure, TRole>);\n    /** Get text content of the message. */\n    get text(): string;\n    get contentBlocks(): Array<ContentBlock.Standard>;\n    toDict(): StoredMessage;\n    static lc_name(): string;\n    // Can't be protected for silly reasons\n    get _printableFields(): Record<string, unknown>;\n    static isInstance(obj: unknown): obj is BaseMessage;\n    // this private method is used to update the ID for the runtime\n    // value as well as in lc_kwargs for serialisation\n    _updateId(value: string | undefined): void;\n    get [Symbol.toStringTag](): any;\n    toFormattedString(format?: MessageStringFormat): string;\n}\n/**\n * @deprecated Use \"tool_calls\" field on AIMessages instead\n */\nexport type OpenAIToolCall = {\n    /**\n     * The ID of the tool call.\n     */\n    id: string;\n    /**\n     * The function that the model called.\n     */\n    function: FunctionCall;\n    /**\n     * The type of the tool. Currently, only `function` is supported.\n     */\n    type: \"function\";\n    index?: number;\n};\nexport declare function isOpenAIToolCallArray(value?: unknown): value is OpenAIToolCall[];\nexport declare function _mergeDicts(\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nleft?: Record<string, any>, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nright?: Record<string, any>\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n): Record<string, any>;\nexport declare function _mergeLists<Content extends ContentBlock>(left?: Content[], right?: Content[]): Content[] | undefined;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare function _mergeObj<T = any>(left: T | undefined, right: T | undefined): T;\n/**\n * Represents a chunk of a message, which can be concatenated with other\n * message chunks. It includes a method `_merge_kwargs_dict()` for merging\n * additional keyword arguments from another `BaseMessageChunk` into this\n * one. It also overrides the `__add__()` method to support concatenation\n * of `BaseMessageChunk` instances.\n */\nexport declare abstract class BaseMessageChunk<TStructure extends MessageStructure = MessageStructure, TRole extends MessageType = MessageType> extends BaseMessage<TStructure, TRole> {\n    abstract concat(chunk: BaseMessageChunk): BaseMessageChunk<TStructure, TRole>;\n    static isInstance(obj: unknown): obj is BaseMessageChunk;\n}\nexport type MessageFieldWithRole = {\n    role: MessageType;\n    content: MessageContent;\n    name?: string;\n} & Record<string, unknown>;\nexport declare function _isMessageFieldWithRole(x: BaseMessageLike): x is MessageFieldWithRole;\nexport type BaseMessageLike = BaseMessage | MessageFieldWithRole | [MessageType, MessageContent] | string\n/**\n * @deprecated Specifying \"type\" is deprecated and will be removed in 0.4.0.\n */\n | ({\n    type: MessageType | \"user\" | \"assistant\" | \"placeholder\";\n} & BaseMessageFields & Record<string, unknown>) | SerializedConstructor;\n/**\n * @deprecated Use {@link BaseMessage.isInstance} instead\n */\nexport declare function isBaseMessage(messageLike?: unknown): messageLike is BaseMessage;\n/**\n * @deprecated Use {@link BaseMessageChunk.isInstance} instead\n */\nexport declare function isBaseMessageChunk(messageLike?: unknown): messageLike is BaseMessageChunk;\nexport {};\n"],"mappings":"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"}