@langchain/core 1.0.6 → 1.1.0

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

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.cts","names":["Document","DocumentLoader","Promise","BaseDocumentLoader"],"sources":["../../src/document_loaders/base.d.ts"],"sourcesContent":["import { Document } from \"../documents/document.js\";\n/**\n * Interface that defines the methods for loading and splitting documents.\n */\nexport interface DocumentLoader {\n    load(): Promise<Document[]>;\n}\n/**\n * Abstract class that provides a default implementation for the\n * loadAndSplit() method from the DocumentLoader interface. The load()\n * method is left abstract and needs to be implemented by subclasses.\n */\nexport declare abstract class BaseDocumentLoader implements DocumentLoader {\n    /**\n     * Loads the documents.\n     * @returns A Promise that resolves with an array of Document instances.\n     */\n    abstract load(): Promise<Document[]>;\n}\n"],"mappings":";;;;;;AAIA;AAA+B,UAAdC,cAAAA,CAAc;EAAA,IACXD,EAAAA,EAARE,OAAQF,CAAAA,QAAAA,EAAAA,CAAAA;;AAAD;AAOnB;;;;AAA4DC,uBAA9BE,kBAAAA,YAA8BF,cAAAA,CAAAA;EAAc;;;;mBAKrDC,QAAQF"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.ts","names":["Document","DocumentLoader","Promise","BaseDocumentLoader"],"sources":["../../src/document_loaders/base.d.ts"],"sourcesContent":["import { Document } from \"../documents/document.js\";\n/**\n * Interface that defines the methods for loading and splitting documents.\n */\nexport interface DocumentLoader {\n    load(): Promise<Document[]>;\n}\n/**\n * Abstract class that provides a default implementation for the\n * loadAndSplit() method from the DocumentLoader interface. The load()\n * method is left abstract and needs to be implemented by subclasses.\n */\nexport declare abstract class BaseDocumentLoader implements DocumentLoader {\n    /**\n     * Loads the documents.\n     * @returns A Promise that resolves with an array of Document instances.\n     */\n    abstract load(): Promise<Document[]>;\n}\n"],"mappings":";;;;;;AAIA;AAA+B,UAAdC,cAAAA,CAAc;EAAA,IACXD,EAAAA,EAARE,OAAQF,CAAAA,QAAAA,EAAAA,CAAAA;;AAAD;AAOnB;;;;AAA4DC,uBAA9BE,kBAAAA,YAA8BF,cAAAA,CAAAA;EAAc;;;;mBAKrDC,QAAQF"}

package/dist/document_loaders/langsmith.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"langsmith.d.cts","names":["KVMap","Client","Document","AsyncCallerParams","BaseDocumentLoader","ClientConfig","RequestInit","LangSmithLoaderFields","Array","Date","LangSmithLoader","Promise"],"sources":["../../src/document_loaders/langsmith.d.ts"],"sourcesContent":["import { KVMap } from \"langsmith/schemas\";\nimport { Client } from \"langsmith\";\nimport { Document } from \"../documents/document.js\";\nimport { AsyncCallerParams } from \"../utils/async_caller.js\";\nimport { BaseDocumentLoader } from \"./base.js\";\n// TODO: Replace with import from `langsmith` once exposed.\ninterface ClientConfig {\n    apiUrl?: string;\n    apiKey?: string;\n    callerOptions?: AsyncCallerParams;\n    timeout_ms?: number;\n    webUrl?: string;\n    anonymizer?: (values: KVMap) => KVMap;\n    hideInputs?: boolean | ((inputs: KVMap) => KVMap);\n    hideOutputs?: boolean | ((outputs: KVMap) => KVMap);\n    autoBatchTracing?: boolean;\n    pendingAutoBatchedRunLimit?: number;\n    fetchOptions?: RequestInit;\n}\nexport interface LangSmithLoaderFields {\n    datasetId?: string;\n    datasetName?: string;\n    exampleIds?: Array<string>;\n    asOf?: Date | string;\n    splits?: string[];\n    inlineS3Urls?: boolean;\n    offset?: number;\n    limit?: number;\n    metadata?: KVMap;\n    filter?: string;\n    contentKey?: string;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    formatContent?: (content: any) => string;\n    client?: Client;\n    clientConfig?: ClientConfig;\n}\n/**\n * Document loader integration with LangSmith.\n *\n * ## [Constructor args](https://api.js.langchain.com/interfaces/_langchain_core.document_loaders_langsmith.LangSmithLoaderFields.html)\n *\n * <details open>\n * <summary><strong>Load</strong></summary>\n *\n * ```typescript\n * import { LangSmithLoader } from '@langchain/core/document_loaders/langsmith';\n * import { Client } from 'langsmith';\n *\n * const langSmithClient = new Client({\n *   apiKey: process.env.LANGSMITH_API_KEY,\n * })\n *\n * const loader = new LangSmithLoader({\n *   datasetId: \"9a3b36f7-b308-40a5-9b46-6613853b6330\",\n *   limit: 1,\n * });\n *\n * const docs = await loader.load();\n * ```\n *\n * ```txt\n * [\n *   {\n *     pageContent: '{\\n  \"input_key_str\": \"string\",\\n  \"input_key_bool\": true\\n}',\n *     metadata: {\n *       id: '8523d9e9-c123-4b23-9b46-21021nds289e',\n *       created_at: '2024-08-19T17:09:14.806441+00:00',\n *       modified_at: '2024-08-19T17:09:14.806441+00:00',\n *       name: '#8517 @ brace-test-dataset',\n *       dataset_id: '9a3b36f7-b308-40a5-9b46-6613853b6330',\n *       source_run_id: null,\n *       metadata: [Object],\n *       inputs: [Object],\n *       outputs: [Object]\n *     }\n *   }\n * ]\n * ```\n * </details>\n */\nexport declare class LangSmithLoader extends BaseDocumentLoader {\n    datasetId?: string;\n    datasetName?: string;\n    exampleIds?: Array<string>;\n    asOf?: Date | string;\n    splits?: string[];\n    inlineS3Urls?: boolean;\n    offset?: number;\n    limit?: number;\n    metadata?: KVMap;\n    filter?: string;\n    contentKey: string[];\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    formatContent: (content: any) => string;\n    client: Client;\n    constructor(fields: LangSmithLoaderFields);\n    load(): Promise<Document[]>;\n}\nexport {};\n"],"mappings":";;;;;;;;UAMUK,YAAAA;EAAAA,MAAAA,CAAAA,EAAAA,MAAY;EAAA,MAAA,CAAA,EAAA,MAAA;EAAA,aAGFF,CAAAA,EAAAA,iBAAAA;EAAiB,UAGXH,CAAAA,EAAAA,MAAAA;EAAK,MAAKA,CAAAA,EAAAA,MAAAA;EAAK,UACJA,CAAAA,EAAAA,CAAAA,MAAAA,EADXA,KACWA,EAAAA,GADDA,KACCA;EAAK,UAAKA,CAAAA,EAAAA,OAAAA,GAAAA,CAAAA,CAAAA,MAAAA,EAAVA,KAAUA,EAAAA,GAAAA,KAAAA,CAAAA;EAAK,WACbA,CAAAA,EAAAA,OAAAA,GAAAA,CAAAA,CAAAA,OAAAA,EAAAA,KAAAA,EAAAA,GAAUA,KAAVA,CAAAA;EAAK,gBAAKA,CAAAA,EAAAA,OAAAA;EAAK,0BAGnCM,CAAAA,EAAAA,MAAAA;EAAW,YAAA,CAAA,EAAXA,WAAW;AAE9B;AAAsC,UAArBC,qBAAAA,CAAqB;EAAA,SAGrBC,CAAAA,EAAAA,MAAAA;EAAK,WACXC,CAAAA,EAAAA,MAAAA;EAAI,UAKAT,CAAAA,EANEQ,KAMFR,CAAAA,MAAAA,CAAAA;EAAK,IAKPC,CAAAA,EAVFQ,IAUER,GAAAA,MAAAA;EAAM,MACAI,CAAAA,EAAAA,MAAAA,EAAAA;EAAY,YAAA,CAAA,EAAA,OAAA;EA8CVK,MAAAA,CAAAA,EAAAA,MAAAA;EAAe,KAAA,CAAA,EAAA,MAAA;EAAA,QAGnBF,CAAAA,EAvDFR,KAuDEQ;EAAK,MACXC,CAAAA,EAAAA,MAAAA;EAAI,UAKAT,CAAAA,EAAAA,MAAAA;EAAK;EAKF,aACMO,CAAAA,EAAAA,CAAAA,OAAAA,EAAAA,GAAAA,EAAAA,GAAAA,MAAAA;EAAqB,MACzBL,CAAAA,EA/DPD,MA+DOC;EAAQ,YAAhBS,CAAAA,EA9DON,YA8DPM;;AAhBmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA1CD,eAAAA,SAAwBN,kBAAAA;;;eAG5BI;SACNC;;;;;aAKIT;;;;;UAKHC;sBACYM;UACZI,QAAQT"}

package/dist/document_loaders/langsmith.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"langsmith.d.ts","names":["KVMap","Client","Document","AsyncCallerParams","BaseDocumentLoader","ClientConfig","RequestInit","LangSmithLoaderFields","Array","Date","LangSmithLoader","Promise"],"sources":["../../src/document_loaders/langsmith.d.ts"],"sourcesContent":["import { KVMap } from \"langsmith/schemas\";\nimport { Client } from \"langsmith\";\nimport { Document } from \"../documents/document.js\";\nimport { AsyncCallerParams } from \"../utils/async_caller.js\";\nimport { BaseDocumentLoader } from \"./base.js\";\n// TODO: Replace with import from `langsmith` once exposed.\ninterface ClientConfig {\n    apiUrl?: string;\n    apiKey?: string;\n    callerOptions?: AsyncCallerParams;\n    timeout_ms?: number;\n    webUrl?: string;\n    anonymizer?: (values: KVMap) => KVMap;\n    hideInputs?: boolean | ((inputs: KVMap) => KVMap);\n    hideOutputs?: boolean | ((outputs: KVMap) => KVMap);\n    autoBatchTracing?: boolean;\n    pendingAutoBatchedRunLimit?: number;\n    fetchOptions?: RequestInit;\n}\nexport interface LangSmithLoaderFields {\n    datasetId?: string;\n    datasetName?: string;\n    exampleIds?: Array<string>;\n    asOf?: Date | string;\n    splits?: string[];\n    inlineS3Urls?: boolean;\n    offset?: number;\n    limit?: number;\n    metadata?: KVMap;\n    filter?: string;\n    contentKey?: string;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    formatContent?: (content: any) => string;\n    client?: Client;\n    clientConfig?: ClientConfig;\n}\n/**\n * Document loader integration with LangSmith.\n *\n * ## [Constructor args](https://api.js.langchain.com/interfaces/_langchain_core.document_loaders_langsmith.LangSmithLoaderFields.html)\n *\n * <details open>\n * <summary><strong>Load</strong></summary>\n *\n * ```typescript\n * import { LangSmithLoader } from '@langchain/core/document_loaders/langsmith';\n * import { Client } from 'langsmith';\n *\n * const langSmithClient = new Client({\n *   apiKey: process.env.LANGSMITH_API_KEY,\n * })\n *\n * const loader = new LangSmithLoader({\n *   datasetId: \"9a3b36f7-b308-40a5-9b46-6613853b6330\",\n *   limit: 1,\n * });\n *\n * const docs = await loader.load();\n * ```\n *\n * ```txt\n * [\n *   {\n *     pageContent: '{\\n  \"input_key_str\": \"string\",\\n  \"input_key_bool\": true\\n}',\n *     metadata: {\n *       id: '8523d9e9-c123-4b23-9b46-21021nds289e',\n *       created_at: '2024-08-19T17:09:14.806441+00:00',\n *       modified_at: '2024-08-19T17:09:14.806441+00:00',\n *       name: '#8517 @ brace-test-dataset',\n *       dataset_id: '9a3b36f7-b308-40a5-9b46-6613853b6330',\n *       source_run_id: null,\n *       metadata: [Object],\n *       inputs: [Object],\n *       outputs: [Object]\n *     }\n *   }\n * ]\n * ```\n * </details>\n */\nexport declare class LangSmithLoader extends BaseDocumentLoader {\n    datasetId?: string;\n    datasetName?: string;\n    exampleIds?: Array<string>;\n    asOf?: Date | string;\n    splits?: string[];\n    inlineS3Urls?: boolean;\n    offset?: number;\n    limit?: number;\n    metadata?: KVMap;\n    filter?: string;\n    contentKey: string[];\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    formatContent: (content: any) => string;\n    client: Client;\n    constructor(fields: LangSmithLoaderFields);\n    load(): Promise<Document[]>;\n}\nexport {};\n"],"mappings":";;;;;;;;UAMUK,YAAAA;EAAAA,MAAAA,CAAAA,EAAAA,MAAY;EAAA,MAAA,CAAA,EAAA,MAAA;EAAA,aAGFF,CAAAA,EAAAA,iBAAAA;EAAiB,UAGXH,CAAAA,EAAAA,MAAAA;EAAK,MAAKA,CAAAA,EAAAA,MAAAA;EAAK,UACJA,CAAAA,EAAAA,CAAAA,MAAAA,EADXA,KACWA,EAAAA,GADDA,KACCA;EAAK,UAAKA,CAAAA,EAAAA,OAAAA,GAAAA,CAAAA,CAAAA,MAAAA,EAAVA,KAAUA,EAAAA,GAAAA,KAAAA,CAAAA;EAAK,WACbA,CAAAA,EAAAA,OAAAA,GAAAA,CAAAA,CAAAA,OAAAA,EAAAA,KAAAA,EAAAA,GAAUA,KAAVA,CAAAA;EAAK,gBAAKA,CAAAA,EAAAA,OAAAA;EAAK,0BAGnCM,CAAAA,EAAAA,MAAAA;EAAW,YAAA,CAAA,EAAXA,WAAW;AAE9B;AAAsC,UAArBC,qBAAAA,CAAqB;EAAA,SAGrBC,CAAAA,EAAAA,MAAAA;EAAK,WACXC,CAAAA,EAAAA,MAAAA;EAAI,UAKAT,CAAAA,EANEQ,KAMFR,CAAAA,MAAAA,CAAAA;EAAK,IAKPC,CAAAA,EAVFQ,IAUER,GAAAA,MAAAA;EAAM,MACAI,CAAAA,EAAAA,MAAAA,EAAAA;EAAY,YAAA,CAAA,EAAA,OAAA;EA8CVK,MAAAA,CAAAA,EAAAA,MAAAA;EAAe,KAAA,CAAA,EAAA,MAAA;EAAA,QAGnBF,CAAAA,EAvDFR,KAuDEQ;EAAK,MACXC,CAAAA,EAAAA,MAAAA;EAAI,UAKAT,CAAAA,EAAAA,MAAAA;EAAK;EAKF,aACMO,CAAAA,EAAAA,CAAAA,OAAAA,EAAAA,GAAAA,EAAAA,GAAAA,MAAAA;EAAqB,MACzBL,CAAAA,EA/DPD,MA+DOC;EAAQ,YAAhBS,CAAAA,EA9DON,YA8DPM;;AAhBmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA1CD,eAAAA,SAAwBN,kBAAAA;;;eAG5BI;SACNC;;;;;aAKIT;;;;;UAKHC;sBACYM;UACZI,QAAQT"}

package/dist/documents/document.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"document.d.cts","names":["DocumentInput","Record","Metadata","DocumentInterface","Document"],"sources":["../../src/documents/document.d.ts"],"sourcesContent":["export interface DocumentInput<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nMetadata extends Record<string, any> = Record<string, any>> {\n    pageContent: string;\n    metadata?: Metadata;\n    /**\n     * An optional identifier for the document.\n     *\n     * Ideally this should be unique across the document collection and formatted\n     * as a UUID, but this will not be enforced.\n     */\n    id?: string;\n}\nexport interface DocumentInterface<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nMetadata extends Record<string, any> = Record<string, any>> {\n    pageContent: string;\n    metadata: Metadata;\n    /**\n     * An optional identifier for the document.\n     *\n     * Ideally this should be unique across the document collection and formatted\n     * as a UUID, but this will not be enforced.\n     */\n    id?: string;\n}\n/**\n * Interface for interacting with a document.\n */\nexport declare class Document<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nMetadata extends Record<string, any> = Record<string, any>> implements DocumentInput, DocumentInterface {\n    pageContent: string;\n    metadata: Metadata;\n    // The ID field is optional at the moment.\n    // It will likely become required in a future major release after\n    // it has been adopted by enough vectorstore implementations.\n    /**\n     * An optional identifier for the document.\n     *\n     * Ideally this should be unique across the document collection and formatted\n     * as a UUID, but this will not be enforced.\n     */\n    id?: string;\n    constructor(fields: DocumentInput<Metadata>);\n}\n"],"mappings":";UAAiBA;AAAjB;iBAEiBC,MAFa,CAAA,MAAA,EAAA,GAAA,CAAA,GAESA,MAFT,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,CAAA;EAAA,WAEbA,EAAAA,MAAAA;EAAM,QAAgBA,CAAAA,EAExBC,QAFwBD;EAAM;AAEtB;AASvB;;;;EAE6C,EAAA,CAE/BC,EAAAA,MAAAA;AAAQ;AAYDE,UAhBJD,iBAgBY;;iBAdZF,MAgBAA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAhBsBA,MAgBtBA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,CAAAA,CAAAA;EAAM,WAAgBA,EAAAA,MAAAA;EAAM,QAE/BC,EAhBAA,QAgBAA;EAAQ;;;;AAFiF;;;;;;;cAFlFE;;iBAEJH,sBAAsBA,gCAAgCD,eAAeG;;YAExED;;;;;;;;;;;sBAWUF,cAAcE"}

package/dist/documents/document.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"document.d.ts","names":["DocumentInput","Record","Metadata","DocumentInterface","Document"],"sources":["../../src/documents/document.d.ts"],"sourcesContent":["export interface DocumentInput<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nMetadata extends Record<string, any> = Record<string, any>> {\n    pageContent: string;\n    metadata?: Metadata;\n    /**\n     * An optional identifier for the document.\n     *\n     * Ideally this should be unique across the document collection and formatted\n     * as a UUID, but this will not be enforced.\n     */\n    id?: string;\n}\nexport interface DocumentInterface<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nMetadata extends Record<string, any> = Record<string, any>> {\n    pageContent: string;\n    metadata: Metadata;\n    /**\n     * An optional identifier for the document.\n     *\n     * Ideally this should be unique across the document collection and formatted\n     * as a UUID, but this will not be enforced.\n     */\n    id?: string;\n}\n/**\n * Interface for interacting with a document.\n */\nexport declare class Document<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nMetadata extends Record<string, any> = Record<string, any>> implements DocumentInput, DocumentInterface {\n    pageContent: string;\n    metadata: Metadata;\n    // The ID field is optional at the moment.\n    // It will likely become required in a future major release after\n    // it has been adopted by enough vectorstore implementations.\n    /**\n     * An optional identifier for the document.\n     *\n     * Ideally this should be unique across the document collection and formatted\n     * as a UUID, but this will not be enforced.\n     */\n    id?: string;\n    constructor(fields: DocumentInput<Metadata>);\n}\n"],"mappings":";UAAiBA;AAAjB;iBAEiBC,MAFa,CAAA,MAAA,EAAA,GAAA,CAAA,GAESA,MAFT,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,CAAA;EAAA,WAEbA,EAAAA,MAAAA;EAAM,QAAgBA,CAAAA,EAExBC,QAFwBD;EAAM;AAEtB;AASvB;;;;EAE6C,EAAA,CAE/BC,EAAAA,MAAAA;AAAQ;AAYDE,UAhBJD,iBAgBY;;iBAdZF,MAgBAA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAhBsBA,MAgBtBA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,CAAAA,CAAAA;EAAM,WAAgBA,EAAAA,MAAAA;EAAM,QAE/BC,EAhBAA,QAgBAA;EAAQ;;;;AAFiF;;;;;;;cAFlFE;;iBAEJH,sBAAsBA,gCAAgCD,eAAeG;;YAExED;;;;;;;;;;;sBAWUF,cAAcE"}

package/dist/documents/transformers.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transformers.d.cts","names":["Runnable","BaseCallbackConfig","DocumentInterface","BaseDocumentTransformer","RunInput","RunOutput","Promise","MappingDocumentTransformer"],"sources":["../../src/documents/transformers.d.ts"],"sourcesContent":["import { Runnable } from \"../runnables/base.js\";\nimport type { BaseCallbackConfig } from \"../callbacks/manager.js\";\nimport type { DocumentInterface } from \"./document.js\";\n/**\n * Abstract base class for document transformation systems.\n *\n * A document transformation system takes an array of Documents and returns an\n * array of transformed Documents. These arrays do not necessarily have to have\n * the same length.\n *\n * One example of this is a text splitter that splits a large document into\n * many smaller documents.\n */\nexport declare abstract class BaseDocumentTransformer<RunInput extends DocumentInterface[] = DocumentInterface[], RunOutput extends DocumentInterface[] = DocumentInterface[]> extends Runnable<RunInput, RunOutput> {\n    lc_namespace: string[];\n    /**\n     * Transform a list of documents.\n     * @param documents A sequence of documents to be transformed.\n     * @returns A list of transformed documents.\n     */\n    abstract transformDocuments(documents: RunInput): Promise<RunOutput>;\n    /**\n     * Method to invoke the document transformation. This method calls the\n     * transformDocuments method with the provided input.\n     * @param input The input documents to be transformed.\n     * @param _options Optional configuration object to customize the behavior of callbacks.\n     * @returns A Promise that resolves to the transformed documents.\n     */\n    invoke(input: RunInput, _options?: BaseCallbackConfig): Promise<RunOutput>;\n}\n/**\n * Class for document transformers that return exactly one transformed document\n * for each input document.\n */\nexport declare abstract class MappingDocumentTransformer extends BaseDocumentTransformer {\n    transformDocuments(documents: DocumentInterface[]): Promise<DocumentInterface[]>;\n    abstract _transformDocument(document: DocumentInterface): Promise<DocumentInterface>;\n}\n"],"mappings":";;;;;;;;AAaA;;;;;;;;AAO2CI,uBAPbD,uBAOaC,CAAAA,iBAP4BF,iBAO5BE,EAAAA,GAPkDF,iBAOlDE,EAAAA,EAAAA,kBAPyFF,iBAOzFE,EAAAA,GAP+GF,iBAO/GE,EAAAA,CAAAA,SAP4IJ,QAO5II,CAPqJA,QAOrJA,EAP+JC,SAO/JD,CAAAA,CAAAA;EAAQ,YAAWC,EAAAA,MAAAA,EAAAA;EAAS;;;;;EAQJ,SAfoHL,kBAAAA,CAAAA,SAAAA,EAO5II,QAP4IJ,CAAAA,EAOjIM,OAPiIN,CAOzHK,SAPyHL,CAAAA;EAAQ;AAqB/L;;;;;;EAE2D,MAAWE,CAAAA,KAAAA,EARpDE,QAQoDF,EAAAA,QAAAA,CAAAA,EAR/BD,kBAQ+BC,CAAAA,EARVI,OAQUJ,CARFG,SAQEH,CAAAA;;;AAFkB;;;uBAA1DK,0BAAAA,SAAmCJ,uBAAAA;gCAC/BD,sBAAsBI,QAAQJ;wCACtBA,oBAAoBI,QAAQJ"}

package/dist/documents/transformers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transformers.d.ts","names":["Runnable","BaseCallbackConfig","DocumentInterface","BaseDocumentTransformer","RunInput","RunOutput","Promise","MappingDocumentTransformer"],"sources":["../../src/documents/transformers.d.ts"],"sourcesContent":["import { Runnable } from \"../runnables/base.js\";\nimport type { BaseCallbackConfig } from \"../callbacks/manager.js\";\nimport type { DocumentInterface } from \"./document.js\";\n/**\n * Abstract base class for document transformation systems.\n *\n * A document transformation system takes an array of Documents and returns an\n * array of transformed Documents. These arrays do not necessarily have to have\n * the same length.\n *\n * One example of this is a text splitter that splits a large document into\n * many smaller documents.\n */\nexport declare abstract class BaseDocumentTransformer<RunInput extends DocumentInterface[] = DocumentInterface[], RunOutput extends DocumentInterface[] = DocumentInterface[]> extends Runnable<RunInput, RunOutput> {\n    lc_namespace: string[];\n    /**\n     * Transform a list of documents.\n     * @param documents A sequence of documents to be transformed.\n     * @returns A list of transformed documents.\n     */\n    abstract transformDocuments(documents: RunInput): Promise<RunOutput>;\n    /**\n     * Method to invoke the document transformation. This method calls the\n     * transformDocuments method with the provided input.\n     * @param input The input documents to be transformed.\n     * @param _options Optional configuration object to customize the behavior of callbacks.\n     * @returns A Promise that resolves to the transformed documents.\n     */\n    invoke(input: RunInput, _options?: BaseCallbackConfig): Promise<RunOutput>;\n}\n/**\n * Class for document transformers that return exactly one transformed document\n * for each input document.\n */\nexport declare abstract class MappingDocumentTransformer extends BaseDocumentTransformer {\n    transformDocuments(documents: DocumentInterface[]): Promise<DocumentInterface[]>;\n    abstract _transformDocument(document: DocumentInterface): Promise<DocumentInterface>;\n}\n"],"mappings":";;;;;;;;AAaA;;;;;;;;AAO2CI,uBAPbD,uBAOaC,CAAAA,iBAP4BF,iBAO5BE,EAAAA,GAPkDF,iBAOlDE,EAAAA,EAAAA,kBAPyFF,iBAOzFE,EAAAA,GAP+GF,iBAO/GE,EAAAA,CAAAA,SAP4IJ,QAO5II,CAPqJA,QAOrJA,EAP+JC,SAO/JD,CAAAA,CAAAA;EAAQ,YAAWC,EAAAA,MAAAA,EAAAA;EAAS;;;;;EAQJ,SAfoHL,kBAAAA,CAAAA,SAAAA,EAO5II,QAP4IJ,CAAAA,EAOjIM,OAPiIN,CAOzHK,SAPyHL,CAAAA;EAAQ;AAqB/L;;;;;;EAE2D,MAAWE,CAAAA,KAAAA,EARpDE,QAQoDF,EAAAA,QAAAA,CAAAA,EAR/BD,kBAQ+BC,CAAAA,EARVI,OAQUJ,CARFG,SAQEH,CAAAA;;;AAFkB;;;uBAA1DK,0BAAAA,SAAmCJ,uBAAAA;gCAC/BD,sBAAsBI,QAAQJ;wCACtBA,oBAAoBI,QAAQJ"}

package/dist/embeddings.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"embeddings.d.cts","names":["AsyncCaller","AsyncCallerParams","EmbeddingsParams","EmbeddingsInterface","TOutput","Promise","Embeddings"],"sources":["../src/embeddings.d.ts"],"sourcesContent":["import { AsyncCaller, AsyncCallerParams } from \"./utils/async_caller.js\";\n/**\n * The parameters required to initialize an instance of the Embeddings\n * class.\n */\nexport type EmbeddingsParams = AsyncCallerParams;\nexport interface EmbeddingsInterface<TOutput = number[]> {\n    /**\n     * An abstract method that takes an array of documents as input and\n     * returns a promise that resolves to an array of vectors for each\n     * document.\n     * @param documents An array of documents to be embedded.\n     * @returns A promise that resolves to an array of vectors for each document.\n     */\n    embedDocuments(documents: string[]): Promise<TOutput[]>;\n    /**\n     * An abstract method that takes a single document as input and returns a\n     * promise that resolves to a vector for the query document.\n     * @param document A single document to be embedded.\n     * @returns A promise that resolves to a vector for the query document.\n     */\n    embedQuery(document: string): Promise<TOutput>;\n}\n/**\n * An abstract class that provides methods for embedding documents and\n * queries using LangChain.\n */\nexport declare abstract class Embeddings<TOutput = number[]> implements EmbeddingsInterface<TOutput> {\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    constructor(params: EmbeddingsParams);\n    /**\n     * An abstract method that takes an array of documents as input and\n     * returns a promise that resolves to an array of vectors for each\n     * document.\n     * @param documents An array of documents to be embedded.\n     * @returns A promise that resolves to an array of vectors for each document.\n     */\n    abstract embedDocuments(documents: string[]): Promise<TOutput[]>;\n    /**\n     * An abstract method that takes a single document as input and returns a\n     * promise that resolves to a vector for the query document.\n     * @param document A single document to be embedded.\n     * @returns A promise that resolves to a vector for the query document.\n     */\n    abstract embedQuery(document: string): Promise<TOutput>;\n}\n"],"mappings":";;;;;;AAKA;AACA;AAAoC,KADxBE,gBAAAA,GAAmBD,iBACK;AAQaG,UARhCD,mBAQgCC,CAAAA,UAAAA,MAAAA,EAAAA,CAAAA,CAAAA;EAAO;;;AAOf;AAMzC;;;EAAmG,cAKvFJ,CAAAA,SAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EAlB6BK,OAkB7BL,CAlBqCI,OAkBrCJ,EAAAA,CAAAA;EAAW;;;;;;EALoE,UAAA,CAAA,QAAA,EAAA,MAAA,CAAA,EANzDK,OAMyD,CANjDD,OAMiD,CAAA;;;;;;uBAA7DE,0CAA0CH,oBAAoBC;;;;;UAKhFJ;sBACYE;;;;;;;;gDAQ0BG,QAAQD;;;;;;;yCAOfC,QAAQD"}

package/dist/embeddings.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"embeddings.d.ts","names":["AsyncCaller","AsyncCallerParams","EmbeddingsParams","EmbeddingsInterface","TOutput","Promise","Embeddings"],"sources":["../src/embeddings.d.ts"],"sourcesContent":["import { AsyncCaller, AsyncCallerParams } from \"./utils/async_caller.js\";\n/**\n * The parameters required to initialize an instance of the Embeddings\n * class.\n */\nexport type EmbeddingsParams = AsyncCallerParams;\nexport interface EmbeddingsInterface<TOutput = number[]> {\n    /**\n     * An abstract method that takes an array of documents as input and\n     * returns a promise that resolves to an array of vectors for each\n     * document.\n     * @param documents An array of documents to be embedded.\n     * @returns A promise that resolves to an array of vectors for each document.\n     */\n    embedDocuments(documents: string[]): Promise<TOutput[]>;\n    /**\n     * An abstract method that takes a single document as input and returns a\n     * promise that resolves to a vector for the query document.\n     * @param document A single document to be embedded.\n     * @returns A promise that resolves to a vector for the query document.\n     */\n    embedQuery(document: string): Promise<TOutput>;\n}\n/**\n * An abstract class that provides methods for embedding documents and\n * queries using LangChain.\n */\nexport declare abstract class Embeddings<TOutput = number[]> implements EmbeddingsInterface<TOutput> {\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    constructor(params: EmbeddingsParams);\n    /**\n     * An abstract method that takes an array of documents as input and\n     * returns a promise that resolves to an array of vectors for each\n     * document.\n     * @param documents An array of documents to be embedded.\n     * @returns A promise that resolves to an array of vectors for each document.\n     */\n    abstract embedDocuments(documents: string[]): Promise<TOutput[]>;\n    /**\n     * An abstract method that takes a single document as input and returns a\n     * promise that resolves to a vector for the query document.\n     * @param document A single document to be embedded.\n     * @returns A promise that resolves to a vector for the query document.\n     */\n    abstract embedQuery(document: string): Promise<TOutput>;\n}\n"],"mappings":";;;;;;AAKA;AACA;AAAoC,KADxBE,gBAAAA,GAAmBD,iBACK;AAQaG,UARhCD,mBAQgCC,CAAAA,UAAAA,MAAAA,EAAAA,CAAAA,CAAAA;EAAO;;;AAOf;AAMzC;;;EAAmG,cAKvFJ,CAAAA,SAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EAlB6BK,OAkB7BL,CAlBqCI,OAkBrCJ,EAAAA,CAAAA;EAAW;;;;;;EALoE,UAAA,CAAA,QAAA,EAAA,MAAA,CAAA,EANzDK,OAMyD,CANjDD,OAMiD,CAAA;;;;;;uBAA7DE,0CAA0CH,oBAAoBC;;;;;UAKhFJ;sBACYE;;;;;;;;gDAQ0BG,QAAQD;;;;;;;yCAOfC,QAAQD"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.cts","names":["Serializable","Example","BaseExampleSelector","Promise"],"sources":["../../src/example_selectors/base.d.ts"],"sourcesContent":["import { Serializable } from \"../load/serializable.js\";\nimport type { Example } from \"../prompts/base.js\";\n/**\n * Base class for example selectors.\n */\nexport declare abstract class BaseExampleSelector extends Serializable {\n    lc_namespace: string[];\n    /**\n     * Adds an example to the example selector.\n     * @param example The example to add to the example selector.\n     * @returns A Promise that resolves to void or a string.\n     */\n    abstract addExample(example: Example): Promise<void | string>;\n    /**\n     * Selects examples from the example selector given the input variables.\n     * @param input_variables The input variables to select examples with.\n     * @returns A Promise that resolves to an array of selected examples.\n     */\n    abstract selectExamples(input_variables: Example): Promise<Example[]>;\n}\n"],"mappings":";;;;;;;AAKA;AAAiD,uBAAnBE,mBAAAA,SAA4BF,YAAAA,CAAT;EAAA,YAOhBC,EAAAA,MAAAA,EAAAA;EAAO;;;;;EAP8B,SAAA,UAAA,CAAA,OAAA,EAOrCA,OAPqC,CAAA,EAO3BE,OAP2B,CAAA,IAAA,GAAA,MAAA,CAAA;;;;;;2CAazBF,UAAUE,QAAQF"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.ts","names":["Serializable","Example","BaseExampleSelector","Promise"],"sources":["../../src/example_selectors/base.d.ts"],"sourcesContent":["import { Serializable } from \"../load/serializable.js\";\nimport type { Example } from \"../prompts/base.js\";\n/**\n * Base class for example selectors.\n */\nexport declare abstract class BaseExampleSelector extends Serializable {\n    lc_namespace: string[];\n    /**\n     * Adds an example to the example selector.\n     * @param example The example to add to the example selector.\n     * @returns A Promise that resolves to void or a string.\n     */\n    abstract addExample(example: Example): Promise<void | string>;\n    /**\n     * Selects examples from the example selector given the input variables.\n     * @param input_variables The input variables to select examples with.\n     * @returns A Promise that resolves to an array of selected examples.\n     */\n    abstract selectExamples(input_variables: Example): Promise<Example[]>;\n}\n"],"mappings":";;;;;;;AAKA;AAAiD,uBAAnBE,mBAAAA,SAA4BF,YAAAA,CAAT;EAAA,YAOhBC,EAAAA,MAAAA,EAAAA;EAAO;;;;;EAP8B,SAAA,UAAA,CAAA,OAAA,EAOrCA,OAPqC,CAAA,EAO3BE,OAP2B,CAAA,IAAA,GAAA,MAAA,CAAA;;;;;;2CAazBF,UAAUE,QAAQF"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"conditional.d.cts","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/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":";;;;;;;;;;;;;;;;;cAeqBuB,gDAAgDvB;AAAhDuB,cACAC,uBADgDxB,EAAAA,CAAAA,SAAa,CAAA,EAAA,MAAA,GAAA,SAAA,EAAA,GAAA,MAAA;AAClF;AAYA;AAMA;AAA4E;AAK5E;;;;;;AAAoG;AACxFiC,cAZSR,mBAeX,EAAA,CAAA,SAAA,EAAA,MAAA,EAAA,GAAA,MAAA;AACV;;;;AAIqB;AAKSW,iBAnBNV,YAAAA,CAmBmB,IAAA,EAAA,OAAA,CAAA,EAAA,IAAA,IAnBkBC,cAmBlB;UAlBjCC,sBAAAA,CAkBiC;EAAA,MAA0CX,EAAAA,MAAAA;EAAc,SAAGA,EAhBvFjB,aAgBuFiB;;AAA2CqB,cAd5HT,kBAc4HS,EAAAA,CAAAA;EAAAA,MAAAA;EAAAA;AAAAA,CAAAA,EAd/EV,sBAc+EU,EAAAA,GAdpDN,OAcoDM,CAAAA,MAAAA,CAAAA;AAAWC,KAbhJN,aAAAA,GAagJM;EAAW,MAKvJ3B,EAAAA,MAAAA;EAAS,KAEVsB,EAAAA,MAAAA;CAAM,GAjBjBA,MAqBoBC,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;AAXsGpB,UAT7GoB,mBAAAA,CAS6GpB;EAAQ,OAA8CoB,CAAAA,EAAAA,OAAAA;EAAmB,SAAA,CAAA,EAPvLvB,SAOuL;EAkBtL4B,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAuB,QAAA,CAAA,EAvBzBN,MAuByB,CAAA,MAAA,EAAA,OAAA,CAAA;;;;;AAA+C,uBAlBzDE,aAkByD,CAAA,QAAA,EAAA,SAAA,EAAA,oBAlBFnB,cAkBE,GAlBeA,cAkBf,CAAA,SAlBuCF,QAkBvC,CAlBgDsB,QAkBhD,EAlB0DC,SAkB1D,EAlBqEC,WAkBrE,CAAA,YAlB6FJ,mBAkB7F,CAAA;EAOtEM;AAkBjB;;EAA6C,OAASxB,EAAAA,OAAAA;EAAc,SAAEwB,CAAAA,EAtCtD7B,SAsCsD6B;EAAmC,IAAA,CAAA,EAAA,MAAA,EAAA;EAOxFE,QAAAA,CAAAA,EA3CFT,MA2CES,CAAAA,MAAkB,EAAA,OAAA,CAAA;EAAA,IAAA,aAAA,CAAA,CAAA,EAAA;IAgBnBT,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAAAA,SAAAA;EAAM,CAAA,GAAoBhB,SAAAA;EAAU,WAAA,CAAA,MAAA,EAvD5BiB,mBAuD4B;AAOpD;AAIA;AAGA;;;;AAAiDO,UA9DhCF,uBAAAA,SAAgC1B,iBA8DA4B,EA9DmBP,mBA8DnBO,CAAAA;EAA4B;AAI7E;;EAAkC,eAAGpC,CAAAA,EA9DfK,eA8DeL;EAAwB,KAAYE,CAAAA,EA7D7DH,SA6D6DG,GAAAA,OAAAA;AAAe;AAC5EuC,UA5DKN,mCAAAA,CA4De;EAAA;;;AAAwB;EAC5CO,2BAAAA,CAAAA,EAAAA;IAQAE;;;IAGA7B,MAAAA,EAAAA;MAA4Ba,MAAAA,EAAAA,MAAAA;IAGvBe,CAAAA;IAAU;AAE3B;;IAEqCP,MAAAA,CAAAA,EAhEpBxB,eAgEoBwB;EAA4B,CAAA;;AAAmFJ,UA7DnII,4BAAAA,SAAqCzB,cA6D8FqB,EA7D9EG,mCA6D8EH,CAAAA;EAAS;;;;EAEzC,IAAW5B,CAAAA,EAAAA,MAAAA,EAAAA;;AAGrGD,UA3DTkC,kBAAAA,CA2DSlC;EAAc;;;;EALmF,IAAA,EAAA,MAAA;EAa/G2C;AACZ;;;;;AAAwC;AAIxC;;;EAEiE,UAAGV,EA1DpDR,MA0DoDQ,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GA1D1BxB,eA0D0BwB;EAA4B;;;;EAAgJ,WAAEH,CAAAA,EAAAA,MAAAA;;AAUtOlC,UA7DKsB,cAAAA,CA6DLtB;EAAS,IACHkD,EAAAA,UAAAA;EAAS,QAAEC,EA5Dfb,kBA4Dea;;AACalD,KA3D9BsC,kBAAAA,GA2D8BtC;EAAwB,IAAyBiC,EAAAA,MAAAA;CAAW;AAAkC7B,UAxDvHmC,uBAAAA,SAAgCH,4BAwDuFhC,CAAAA;EAAS,aAAjBsB,CAAAA,EAvD5GY,kBAuD4GZ;EAAO,SAS7GvB,CAAAA,EA/DVkC,kBA+DUlC,EAAAA;;AAC6BqC,KA9D3CA,sBAAAA,GAAyBxC,wBA8DkBwC,GAAAA,MAAAA,GA9DkBtC,eA8DlBsC,EAAAA;AAAyBxC,KA7DpEyC,oBAAAA,GAAuB5B,qBA6D6Cb,CA7DvBc,gBA6DuBd,CAAAA;AAKtD4B,KAjEdc,6BAiEcd,CAAAA,mBAAAA,OAAAA,GAAAA,KAAAA,CAAAA,GAAAA;EAAM,IAQ1BuB,CAAAA,EAAAA,MAAAA;EAAM,MAAoBlB,CAAAA,EAAAA,iBAAAA,GAAAA,UAAAA,GAAAA,YAAAA,GAAAA,MAAAA;EAAW,UAC1BtB,CAAAA,EAvEAgC,UAuEAhC;EAAc;EAMD,MAKAgB,CAAAA,EAAAA,OAAAA;CAAa;;AAMxBX,KAnFP4B,4BAmFO5B,CAAAA,SAAAA,EAAAA,mBAAAA,OAAAA,GAAAA,KAAAA,CAAAA,GAAAA;EAAY;EAGH;EAAsB,MAAiCgB,EAnFvEjB,cAmFuEiB,CAnFxDA,SAmFwDA,CAAAA,GAnF3CJ,MAmF2CI,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;EAAS,IAAnBpC,CAAAA,EAAAA,MAAAA;EAAS,MAE3EgC,CAAAA,EAAAA,iBAAAA,GAAAA,UAAAA;EAAM,UAAwBc,CAAAA,EAlFpBC,UAkFoBD;CAA6B;AAA2CV,UAhF5Fa,0BAgF4Fb;;YAGvFJ,GAAAA,EAAAA,oBAjFeQ,4BAiFfR,GAjF8CQ,4BAiF9CR,CAAAA,SAjFoFlB,iBAiFpFkB,CAjFsGY,sBAiFtGZ,EAjF8HI,SAiF9HJ,EAjFyIK,WAiFzIL,CAAAA,CAAAA;EAAM,IAAgBA,QAAAA,EAAAA,EAAAA,MAAAA,EAAAA;EAAM,cAAiCI,CAAAA,YAAAA,EA/ElDhC,wBA+EkDgC,EAAAA,EAAAA,OAAAA,CAAAA,EAAAA,MAAAA,EAAAA,GA/EDC,WA+ECD,EAAAA,SAAAA,CAAAA,EA/EwB1B,SA+ExB0B,CAAAA,EA/EoCN,OA+EpCM,CA/E4C5B,SA+E5C4B,CAAAA;EAAS,UAAnBpC,EAAAA,EAAAA,MAAAA;EAAS,QAE3EgC,EAAAA,EAAAA,MAAAA;EAAM,YAAwBc,CAAAA,OAAAA,EA9EXvC,cA8EWuC,CAAAA,EA9EMhB,OA8ENgB,CAAAA,MAAAA,CAAAA;EAA6B;;;EAEzC;EAF0D,kBAM7Dd,EAAAA,EA/EIA,MA+EJA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;EAAM,SAAgBA,EAAAA,EA9E3BD,aA8E2BC;;AAA6B9B,KA5E7DgD,mBAAAA,GAAsB7C,WA4EuCH,GAAAA,MAAAA;AAElE8B,KA7EKmB,iBAAAA,GAAoBtC,QA6EzBmB,CA7EkCY,sBA6ElCZ,EA7E0DkB,mBA6E1DlB,CAAAA;;;;AAAqEnB,uBAzE9CuC,iBAyE8CvC;;YAGhCmB,GAAAA,EAAAA,oBA1EPQ,4BA0EOR,GA1EwBQ,4BA0ExBR,CAAAA,SA1E8DE,aA0E9DF,CA1E4EY,sBA0E5EZ,EA1EoGI,SA0EpGJ,EA1E+GK,WA0E/GL,CAAAA,YA1EuIM,uBA0EvIN,EA1EgKiB,0BA0EhKjB,CA1E2LI,SA0E3LJ,EA1EsMK,WA0EtML,CAAAA,CAAAA;EAAM;;;EAErC,IAAwBc,QAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAA6B;;;;EAAiB,MAmB7Dd,EAtFVrB,WAsFUqB;EAAM,KAAgBA,CAAAA,EArFhC7B,SAqFgC6B;EAAM,WAAsCI,CAAAA;IAAAA,SAAAA;IAAAA,eAAAA;IAAAA,GAAAA;EAAAA,CAAAA,EApF7BE,uBAoF6BF;EAAS,SAAxBjB,cAAAA,CAAAA,YAAAA,EAnF/Bf,wBAmF+Be,EAAAA,EAAAA,OAAAA,CAAAA,EAAAA,MAAAA,EAAAA,GAnFkBkB,WAmFlBlB,EAAAA,SAAAA,CAAAA,EAnF2CT,SAmF3CS,CAAAA,EAnFuDW,OAmFvDX,CAnF+DX,SAmF/DW,CAAAA;EAAc,SAEhFa,UAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAM,SAAwBc,QAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAA6B,QAAqBF,SAAAA;EAAsB;;;;;EAEpF,YAFmG/B,CAAAA,OAAAA,EA5ElGN,cA4EkGM,CAAAA,EA5EjFiB,OA4EiFjB,CAAAA,MAAAA,CAAAA;EAAQ,iBAjG1BqB,0BAAAA,CAAAA,KAAAA,EAsBnDU,sBAtBmDV,CAAAA,EAsB1B9B,wBAtB0B8B;EAAa;;AAA+G;EA0GrNsB;wBA/ESxB;;;;;;;;;;;KAQMK;aACftB;;;;;;eAMAgB;;;;;4BAKaA,gBAAgBD,QAAQsB;;;;;;iBAMnChC;;;oBAGGY,sBAAsBA,6BAA6BhC,QAAUoC;;IAE5EJ,8BAA8Bc,uCAAuCjC,SAAS+B,wBAAwBR;;;oBAGvFJ,sBAAsBA,6BAA6BhC,QAAUoC;;IAE5EJ,8BAA8Bc,sCAAsCjC,SAAS+B;SACvEvC;YACG+B;;;;oBAIMJ,sBAAsBA,6BAA6B9B,SAAUkC;;IAE5EJ,8BAA8Bc,uCAAuCjC,SAAS+B,wBAAwBR;;;oBAGvFJ,sBAAsBA,6BAA6B9B,SAAUkC;;IAE5EJ,8BAA8Bc,sCAAsCjC,SAAS+B;SACvEvC;YACG+B;;;;;;;;;;;;;;;;;oBAiBMJ,sBAAsBA,6BAA6Bb,eAAeiB;;IAEjFJ,8BAA8Bc,yCAAyCjC,SAAS+B,wBAAwBR,aAAavB,SAAS+B;SACxHvC;YACG+B;;;;;;;UAOCoB,UAAAA"}

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":"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"}

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"}