@langchain/core 1.0.0-alpha.5 → 1.0.0-alpha.7

package/dist/retrievers/index.d.ts

@@ -1,5 +1,5 @@
 import { DocumentInterface } from "../documents/document.js";
-import { BaseCallbackConfig, CallbackManagerForRetrieverRun, Callbacks } from "../callbacks/manager.js";
+import { CallbackManagerForRetrieverRun, Callbacks } from "../callbacks/manager.js";
 import { RunnableConfig, RunnableInterface } from "../runnables/types.js";
 import { Runnable } from "../runnables/base.js";
 
@@ -43,19 +43,7 @@ interface BaseRetrieverInput {
  */
 interface BaseRetrieverInterface<
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-Metadata extends Record<string, any> = Record<string, any>> extends RunnableInterface<string, DocumentInterface<Metadata>[]> {
-  /**
-   * Retrieves documents relevant to a given query, allowing optional
-   * configurations for customization.
-   *
-   * @param query - A string representing the query to search for relevant documents.
-   * @param config - (optional) Configuration options for the retrieval process,
-   *                 which may include callbacks and additional context settings.
-   * @returns A promise that resolves to an array of `DocumentInterface` instances,
-   *          each containing metadata specified by the `Metadata` type parameter.
-   */
-  getRelevantDocuments(query: string, config?: Callbacks | BaseCallbackConfig): Promise<DocumentInterface<Metadata>[]>;
-}
+Metadata extends Record<string, any> = Record<string, any>> extends RunnableInterface<string, DocumentInterface<Metadata>[]> {}
 /**
  * Abstract base class for a document retrieval system, designed to
  * process string queries and return the most relevant documents from a source.
@@ -125,19 +113,6 @@ Metadata extends Record<string, any> = Record<string, any>> extends Runnable<str
    *          representing the most relevant documents to the query.
    */
   invoke(input: string, options?: RunnableConfig): Promise<DocumentInterface<Metadata>[]>;
-  /**
-   * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
-   *
-   * Main method used to retrieve relevant documents. It takes a query
-   * string and an optional configuration object, and returns a promise that
-   * resolves to an array of `Document` objects. This method handles the
-   * retrieval process, including starting and ending callbacks, and error
-   * handling.
-   * @param query The query string to retrieve relevant documents for.
-   * @param config Optional configuration object for the retrieval process.
-   * @returns A promise that resolves to an array of `Document` objects.
-   */
-  getRelevantDocuments(query: string, config?: Callbacks | BaseCallbackConfig): Promise<DocumentInterface<Metadata>[]>;
 }
 //#endregion
 export { BaseRetriever, BaseRetrieverInput, BaseRetrieverInterface };

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["BaseCallbackConfig","CallbackManagerForRetrieverRun","Callbacks","DocumentInterface","Runnable","RunnableInterface","RunnableConfig","BaseRetrieverInput","Record","BaseRetrieverInterface","Metadata","Promise","BaseRetriever"],"sources":["../../src/retrievers/index.d.ts"],"sourcesContent":["import { BaseCallbackConfig, CallbackManagerForRetrieverRun, Callbacks } from \"../callbacks/manager.js\";\nimport type { DocumentInterface } from \"../documents/document.js\";\nimport { Runnable, type RunnableInterface } from \"../runnables/base.js\";\nimport { RunnableConfig } from \"../runnables/config.js\";\n/**\n * Input configuration options for initializing a retriever that extends\n * the `BaseRetriever` class. This interface provides base properties\n * common to all retrievers, allowing customization of callback functions,\n * tagging, metadata, and logging verbosity.\n *\n * Fields:\n * - `callbacks` (optional): An array of callback functions that handle various\n *   events during retrieval, such as logging, error handling, or progress updates.\n *\n * - `tags` (optional): An array of strings used to add contextual tags to\n *   retrieval operations, allowing for easier categorization and tracking.\n *\n * - `metadata` (optional): A record of key-value pairs to store additional\n *   contextual information for retrieval operations, which can be useful\n *   for logging or auditing purposes.\n *\n * - `verbose` (optional): A boolean flag that, if set to `true`, enables\n *   detailed logging and output during the retrieval process. Defaults to `false`.\n */\nexport interface BaseRetrieverInput {\n    callbacks?: Callbacks;\n    tags?: string[];\n    metadata?: Record<string, unknown>;\n    verbose?: boolean;\n}\n/**\n * Interface for a base retriever that defines core functionality for\n * retrieving relevant documents from a source based on a query.\n *\n * The `BaseRetrieverInterface` standardizes the `getRelevantDocuments` method,\n * enabling retrieval of documents that match the query criteria.\n *\n * @template Metadata - The type of metadata associated with each document,\n *                      defaulting to `Record<string, any>`.\n */\nexport interface BaseRetrieverInterface<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nMetadata extends Record<string, any> = Record<string, any>> extends RunnableInterface<string, DocumentInterface<Metadata>[]> {\n    /**\n     * Retrieves documents relevant to a given query, allowing optional\n     * configurations for customization.\n     *\n     * @param query - A string representing the query to search for relevant documents.\n     * @param config - (optional) Configuration options for the retrieval process,\n     *                 which may include callbacks and additional context settings.\n     * @returns A promise that resolves to an array of `DocumentInterface` instances,\n     *          each containing metadata specified by the `Metadata` type parameter.\n     */\n    getRelevantDocuments(query: string, config?: Callbacks | BaseCallbackConfig): Promise<DocumentInterface<Metadata>[]>;\n}\n/**\n * Abstract base class for a document retrieval system, designed to\n * process string queries and return the most relevant documents from a source.\n *\n * `BaseRetriever` provides common properties and methods for derived retrievers,\n * such as callbacks, tagging, and verbose logging. Custom retrieval systems\n * should extend this class and implement `_getRelevantDocuments` to define\n * the specific retrieval logic.\n *\n * @template Metadata - The type of metadata associated with each document,\n *                      defaulting to `Record<string, any>`.\n */\nexport declare abstract class BaseRetriever<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nMetadata extends Record<string, any> = Record<string, any>> extends Runnable<string, DocumentInterface<Metadata>[]> implements BaseRetrieverInterface {\n    /**\n     * Optional callbacks to handle various events in the retrieval process.\n     */\n    callbacks?: Callbacks;\n    /**\n     * Tags to label or categorize the retrieval operation.\n     */\n    tags?: string[];\n    /**\n     * Metadata to provide additional context or information about the retrieval\n     * operation.\n     */\n    metadata?: Record<string, unknown>;\n    /**\n     * If set to `true`, enables verbose logging for the retrieval process.\n     */\n    verbose?: boolean;\n    /**\n     * Constructs a new `BaseRetriever` instance with optional configuration fields.\n     *\n     * @param fields - Optional input configuration that can include `callbacks`,\n     *                 `tags`, `metadata`, and `verbose` settings for custom retriever behavior.\n     */\n    constructor(fields?: BaseRetrieverInput);\n    /**\n     * TODO: This should be an abstract method, but we'd like to avoid breaking\n     * changes to people currently using subclassed custom retrievers.\n     * Change it on next major release.\n     */\n    /**\n     * Placeholder method for retrieving relevant documents based on a query.\n     *\n     * This method is intended to be implemented by subclasses and will be\n     * converted to an abstract method in the next major release. Currently, it\n     * throws an error if not implemented, ensuring that custom retrievers define\n     * the specific retrieval logic.\n     *\n     * @param _query - The query string used to search for relevant documents.\n     * @param _callbacks - (optional) Callback manager for managing callbacks\n     *                     during retrieval.\n     * @returns A promise resolving to an array of `DocumentInterface` instances relevant to the query.\n     * @throws {Error} Throws an error indicating the method is not implemented.\n     */\n    _getRelevantDocuments(_query: string, _callbacks?: CallbackManagerForRetrieverRun): Promise<DocumentInterface<Metadata>[]>;\n    /**\n     * Executes a retrieval operation.\n     *\n     * @param input - The query string used to search for relevant documents.\n     * @param options - (optional) Configuration options for the retrieval run,\n     *                  which may include callbacks, tags, and metadata.\n     * @returns A promise that resolves to an array of `DocumentInterface` instances\n     *          representing the most relevant documents to the query.\n     */\n    invoke(input: string, options?: RunnableConfig): Promise<DocumentInterface<Metadata>[]>;\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     *\n     * Main method used to retrieve relevant documents. It takes a query\n     * string and an optional configuration object, and returns a promise that\n     * resolves to an array of `Document` objects. This method handles the\n     * retrieval process, including starting and ending callbacks, and error\n     * handling.\n     * @param query The query string to retrieve relevant documents for.\n     * @param config Optional configuration object for the retrieval process.\n     * @returns A promise that resolves to an array of `Document` objects.\n     */\n    getRelevantDocuments(query: string, config?: Callbacks | BaseCallbackConfig): Promise<DocumentInterface<Metadata>[]>;\n}\n"],"mappings":";;;;;;;;;AAwBA;;;;AAGqB;AAarB;;;;;;;;;;;;AAEqF;AAyBvDY,UA3CbL,kBAAAA,CA2C0B;EAAA,SAAA,CAAA,EA1C3BL,SA0C2B;EAAA,IAE1BM,CAAAA,EAAAA,MAAAA,EAAAA;EAAM,QAAgBA,CAAAA,EA1CxBA,MA0CwBA,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;EAAM,OAA0DE,CAAAA,EAAAA,OAAAA;;;;;;;;;;;;AAsDlDC,UAnFpCF,sBAmFoCE;;iBAjFpCH,MA8F4CR,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GA9FtBQ,MA8FsBR,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,CAAAA,SA9FOK,iBA8FPL,CAAAA,MAAAA,EA9FiCG,iBA8FjCH,CA9FmDU,QA8FnDV,CAAAA,EAAAA,CAAAA,CAAAA;EAAkB;;;;;AAnEsE;;;;;+CAhBpGE,YAAYF,qBAAqBW,QAAQR,kBAAkBO;;;;;;;;;;;;;;uBAc9EE;;iBAEbJ,sBAAsBA,6BAA6BJ,iBAAiBD,kBAAkBO,wBAAwBD;;;;cAI/GP;;;;;;;;;aASDM;;;;;;;;;;;uBAWUD;;;;;;;;;;;;;;;;;;;;qDAoB8BN,iCAAiCU,QAAQR,kBAAkBO;;;;;;;;;;kCAU9EJ,iBAAiBK,QAAQR,kBAAkBO;;;;;;;;;;;;;+CAa9BR,YAAYF,qBAAqBW,QAAQR,kBAAkBO"}
+{"version":3,"file":"index.d.ts","names":["CallbackManagerForRetrieverRun","Callbacks","DocumentInterface","Runnable","RunnableInterface","RunnableConfig","BaseRetrieverInput","Record","BaseRetrieverInterface","Metadata","BaseRetriever","Promise"],"sources":["../../src/retrievers/index.d.ts"],"sourcesContent":["import { CallbackManagerForRetrieverRun, Callbacks } from \"../callbacks/manager.js\";\nimport type { DocumentInterface } from \"../documents/document.js\";\nimport { Runnable, type RunnableInterface } from \"../runnables/base.js\";\nimport { RunnableConfig } from \"../runnables/config.js\";\n/**\n * Input configuration options for initializing a retriever that extends\n * the `BaseRetriever` class. This interface provides base properties\n * common to all retrievers, allowing customization of callback functions,\n * tagging, metadata, and logging verbosity.\n *\n * Fields:\n * - `callbacks` (optional): An array of callback functions that handle various\n *   events during retrieval, such as logging, error handling, or progress updates.\n *\n * - `tags` (optional): An array of strings used to add contextual tags to\n *   retrieval operations, allowing for easier categorization and tracking.\n *\n * - `metadata` (optional): A record of key-value pairs to store additional\n *   contextual information for retrieval operations, which can be useful\n *   for logging or auditing purposes.\n *\n * - `verbose` (optional): A boolean flag that, if set to `true`, enables\n *   detailed logging and output during the retrieval process. Defaults to `false`.\n */\nexport interface BaseRetrieverInput {\n    callbacks?: Callbacks;\n    tags?: string[];\n    metadata?: Record<string, unknown>;\n    verbose?: boolean;\n}\n/**\n * Interface for a base retriever that defines core functionality for\n * retrieving relevant documents from a source based on a query.\n *\n * The `BaseRetrieverInterface` standardizes the `getRelevantDocuments` method,\n * enabling retrieval of documents that match the query criteria.\n *\n * @template Metadata - The type of metadata associated with each document,\n *                      defaulting to `Record<string, any>`.\n */\nexport interface BaseRetrieverInterface<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nMetadata extends Record<string, any> = Record<string, any>> extends RunnableInterface<string, DocumentInterface<Metadata>[]> {\n}\n/**\n * Abstract base class for a document retrieval system, designed to\n * process string queries and return the most relevant documents from a source.\n *\n * `BaseRetriever` provides common properties and methods for derived retrievers,\n * such as callbacks, tagging, and verbose logging. Custom retrieval systems\n * should extend this class and implement `_getRelevantDocuments` to define\n * the specific retrieval logic.\n *\n * @template Metadata - The type of metadata associated with each document,\n *                      defaulting to `Record<string, any>`.\n */\nexport declare abstract class BaseRetriever<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nMetadata extends Record<string, any> = Record<string, any>> extends Runnable<string, DocumentInterface<Metadata>[]> implements BaseRetrieverInterface {\n    /**\n     * Optional callbacks to handle various events in the retrieval process.\n     */\n    callbacks?: Callbacks;\n    /**\n     * Tags to label or categorize the retrieval operation.\n     */\n    tags?: string[];\n    /**\n     * Metadata to provide additional context or information about the retrieval\n     * operation.\n     */\n    metadata?: Record<string, unknown>;\n    /**\n     * If set to `true`, enables verbose logging for the retrieval process.\n     */\n    verbose?: boolean;\n    /**\n     * Constructs a new `BaseRetriever` instance with optional configuration fields.\n     *\n     * @param fields - Optional input configuration that can include `callbacks`,\n     *                 `tags`, `metadata`, and `verbose` settings for custom retriever behavior.\n     */\n    constructor(fields?: BaseRetrieverInput);\n    /**\n     * TODO: This should be an abstract method, but we'd like to avoid breaking\n     * changes to people currently using subclassed custom retrievers.\n     * Change it on next major release.\n     */\n    /**\n     * Placeholder method for retrieving relevant documents based on a query.\n     *\n     * This method is intended to be implemented by subclasses and will be\n     * converted to an abstract method in the next major release. Currently, it\n     * throws an error if not implemented, ensuring that custom retrievers define\n     * the specific retrieval logic.\n     *\n     * @param _query - The query string used to search for relevant documents.\n     * @param _callbacks - (optional) Callback manager for managing callbacks\n     *                     during retrieval.\n     * @returns A promise resolving to an array of `DocumentInterface` instances relevant to the query.\n     * @throws {Error} Throws an error indicating the method is not implemented.\n     */\n    _getRelevantDocuments(_query: string, _callbacks?: CallbackManagerForRetrieverRun): Promise<DocumentInterface<Metadata>[]>;\n    /**\n     * Executes a retrieval operation.\n     *\n     * @param input - The query string used to search for relevant documents.\n     * @param options - (optional) Configuration options for the retrieval run,\n     *                  which may include callbacks, tags, and metadata.\n     * @returns A promise that resolves to an array of `DocumentInterface` instances\n     *          representing the most relevant documents to the query.\n     */\n    invoke(input: string, options?: RunnableConfig): Promise<DocumentInterface<Metadata>[]>;\n}\n"],"mappings":";;;;;;;;;AAwBA;;;;AAGqB;AAarB;;;;;;;AAEqF;AAcrF;;;;;AAEqFE,UAlCpEI,kBAAAA,CAkCoEJ;EAAiB,SAItFD,CAAAA,EArCAA,SAqCAA;EAAS,IASVM,CAAAA,EAAAA,MAAAA,EAAAA;EAAM,QAWID,CAAAA,EAvDVC,MAuDUD,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;EAAkB,OAoBYN,CAAAA,EAAAA,OAAAA;;;;;;;;;;AA5C8F;;UAlBpIQ;;iBAEAD,sBAAsBA,6BAA6BH,0BAA0BF,kBAAkBO;;;;;;;;;;;;;uBAclFC;;iBAEbH,sBAAsBA,6BAA6BJ,iBAAiBD,kBAAkBO,wBAAwBD;;;;cAI/GP;;;;;;;;;aASDM;;;;;;;;;;;uBAWUD;;;;;;;;;;;;;;;;;;;;qDAoB8BN,iCAAiCW,QAAQT,kBAAkBO;;;;;;;;;;kCAU9EJ,iBAAiBM,QAAQT,kBAAkBO"}

package/dist/retrievers/index.js

@@ -81,26 +81,11 @@ var BaseRetriever = class extends Runnable {
 	*          representing the most relevant documents to the query.
 	*/
 	async invoke(input, options) {
-		return this.getRelevantDocuments(input, ensureConfig(options));
-	}
-	/**
-	* @deprecated Use .invoke() instead. Will be removed in 0.3.0.
-	*
-	* Main method used to retrieve relevant documents. It takes a query
-	* string and an optional configuration object, and returns a promise that
-	* resolves to an array of `Document` objects. This method handles the
-	* retrieval process, including starting and ending callbacks, and error
-	* handling.
-	* @param query The query string to retrieve relevant documents for.
-	* @param config Optional configuration object for the retrieval process.
-	* @returns A promise that resolves to an array of `Document` objects.
-	*/
-	async getRelevantDocuments(query, config) {
-		const parsedConfig = ensureConfig(parseCallbackConfigArg(config));
+		const parsedConfig = ensureConfig(parseCallbackConfigArg(options));
 		const callbackManager_ = await CallbackManager.configure(parsedConfig.callbacks, this.callbacks, parsedConfig.tags, this.tags, parsedConfig.metadata, this.metadata, { verbose: this.verbose });
-		const runManager = await callbackManager_?.handleRetrieverStart(this.toJSON(), query, parsedConfig.runId, void 0, void 0, void 0, parsedConfig.runName);
+		const runManager = await callbackManager_?.handleRetrieverStart(this.toJSON(), input, parsedConfig.runId, void 0, void 0, void 0, parsedConfig.runName);
 		try {
-			const results = await this._getRelevantDocuments(query, runManager);
+			const results = await this._getRelevantDocuments(input, runManager);
 			await runManager?.handleRetrieverEnd(results);
 			return results;
 		} catch (error) {

package/dist/retrievers/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["fields?: BaseRetrieverInput","_query: string","_callbacks?: CallbackManagerForRetrieverRun","input: string","options?: RunnableConfig","query: string","config?: Callbacks | BaseCallbackConfig"],"sources":["../../src/retrievers/index.ts"],"sourcesContent":["import {\n  BaseCallbackConfig,\n  CallbackManager,\n  CallbackManagerForRetrieverRun,\n  Callbacks,\n  parseCallbackConfigArg,\n} from \"../callbacks/manager.js\";\nimport type { DocumentInterface } from \"../documents/document.js\";\nimport { Runnable, type RunnableInterface } from \"../runnables/base.js\";\nimport { RunnableConfig, ensureConfig } from \"../runnables/config.js\";\n\n/**\n * Input configuration options for initializing a retriever that extends\n * the `BaseRetriever` class. This interface provides base properties\n * common to all retrievers, allowing customization of callback functions,\n * tagging, metadata, and logging verbosity.\n *\n * Fields:\n * - `callbacks` (optional): An array of callback functions that handle various\n *   events during retrieval, such as logging, error handling, or progress updates.\n *\n * - `tags` (optional): An array of strings used to add contextual tags to\n *   retrieval operations, allowing for easier categorization and tracking.\n *\n * - `metadata` (optional): A record of key-value pairs to store additional\n *   contextual information for retrieval operations, which can be useful\n *   for logging or auditing purposes.\n *\n * - `verbose` (optional): A boolean flag that, if set to `true`, enables\n *   detailed logging and output during the retrieval process. Defaults to `false`.\n */\nexport interface BaseRetrieverInput {\n  callbacks?: Callbacks;\n  tags?: string[];\n  metadata?: Record<string, unknown>;\n  verbose?: boolean;\n}\n\n/**\n * Interface for a base retriever that defines core functionality for\n * retrieving relevant documents from a source based on a query.\n *\n * The `BaseRetrieverInterface` standardizes the `getRelevantDocuments` method,\n * enabling retrieval of documents that match the query criteria.\n *\n * @template Metadata - The type of metadata associated with each document,\n *                      defaulting to `Record<string, any>`.\n */\nexport interface BaseRetrieverInterface<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  Metadata extends Record<string, any> = Record<string, any>\n> extends RunnableInterface<string, DocumentInterface<Metadata>[]> {\n  /**\n   * Retrieves documents relevant to a given query, allowing optional\n   * configurations for customization.\n   *\n   * @param query - A string representing the query to search for relevant documents.\n   * @param config - (optional) Configuration options for the retrieval process,\n   *                 which may include callbacks and additional context settings.\n   * @returns A promise that resolves to an array of `DocumentInterface` instances,\n   *          each containing metadata specified by the `Metadata` type parameter.\n   */\n  getRelevantDocuments(\n    query: string,\n    config?: Callbacks | BaseCallbackConfig\n  ): Promise<DocumentInterface<Metadata>[]>;\n}\n\n/**\n * Abstract base class for a document retrieval system, designed to\n * process string queries and return the most relevant documents from a source.\n *\n * `BaseRetriever` provides common properties and methods for derived retrievers,\n * such as callbacks, tagging, and verbose logging. Custom retrieval systems\n * should extend this class and implement `_getRelevantDocuments` to define\n * the specific retrieval logic.\n *\n * @template Metadata - The type of metadata associated with each document,\n *                      defaulting to `Record<string, any>`.\n */\nexport abstract class BaseRetriever<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Metadata extends Record<string, any> = Record<string, any>\n  >\n  extends Runnable<string, DocumentInterface<Metadata>[]>\n  implements BaseRetrieverInterface\n{\n  /**\n   * Optional callbacks to handle various events in the retrieval process.\n   */\n  callbacks?: Callbacks;\n\n  /**\n   * Tags to label or categorize the retrieval operation.\n   */\n  tags?: string[];\n\n  /**\n   * Metadata to provide additional context or information about the retrieval\n   * operation.\n   */\n  metadata?: Record<string, unknown>;\n\n  /**\n   * If set to `true`, enables verbose logging for the retrieval process.\n   */\n  verbose?: boolean;\n\n  /**\n   * Constructs a new `BaseRetriever` instance with optional configuration fields.\n   *\n   * @param fields - Optional input configuration that can include `callbacks`,\n   *                 `tags`, `metadata`, and `verbose` settings for custom retriever behavior.\n   */\n  constructor(fields?: BaseRetrieverInput) {\n    super(fields);\n    this.callbacks = fields?.callbacks;\n    this.tags = fields?.tags ?? [];\n    this.metadata = fields?.metadata ?? {};\n    this.verbose = fields?.verbose ?? false;\n  }\n\n  /**\n   * TODO: This should be an abstract method, but we'd like to avoid breaking\n   * changes to people currently using subclassed custom retrievers.\n   * Change it on next major release.\n   */\n  /**\n   * Placeholder method for retrieving relevant documents based on a query.\n   *\n   * This method is intended to be implemented by subclasses and will be\n   * converted to an abstract method in the next major release. Currently, it\n   * throws an error if not implemented, ensuring that custom retrievers define\n   * the specific retrieval logic.\n   *\n   * @param _query - The query string used to search for relevant documents.\n   * @param _callbacks - (optional) Callback manager for managing callbacks\n   *                     during retrieval.\n   * @returns A promise resolving to an array of `DocumentInterface` instances relevant to the query.\n   * @throws {Error} Throws an error indicating the method is not implemented.\n   */\n  _getRelevantDocuments(\n    _query: string,\n    _callbacks?: CallbackManagerForRetrieverRun\n  ): Promise<DocumentInterface<Metadata>[]> {\n    throw new Error(\"Not implemented!\");\n  }\n\n  /**\n   * Executes a retrieval operation.\n   *\n   * @param input - The query string used to search for relevant documents.\n   * @param options - (optional) Configuration options for the retrieval run,\n   *                  which may include callbacks, tags, and metadata.\n   * @returns A promise that resolves to an array of `DocumentInterface` instances\n   *          representing the most relevant documents to the query.\n   */\n  async invoke(\n    input: string,\n    options?: RunnableConfig\n  ): Promise<DocumentInterface<Metadata>[]> {\n    return this.getRelevantDocuments(input, ensureConfig(options));\n  }\n\n  /**\n   * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n   *\n   * Main method used to retrieve relevant documents. It takes a query\n   * string and an optional configuration object, and returns a promise that\n   * resolves to an array of `Document` objects. This method handles the\n   * retrieval process, including starting and ending callbacks, and error\n   * handling.\n   * @param query The query string to retrieve relevant documents for.\n   * @param config Optional configuration object for the retrieval process.\n   * @returns A promise that resolves to an array of `Document` objects.\n   */\n  async getRelevantDocuments(\n    query: string,\n    config?: Callbacks | BaseCallbackConfig\n  ): Promise<DocumentInterface<Metadata>[]> {\n    const parsedConfig = ensureConfig(parseCallbackConfigArg(config));\n    const callbackManager_ = await CallbackManager.configure(\n      parsedConfig.callbacks,\n      this.callbacks,\n      parsedConfig.tags,\n      this.tags,\n      parsedConfig.metadata,\n      this.metadata,\n      { verbose: this.verbose }\n    );\n    const runManager = await callbackManager_?.handleRetrieverStart(\n      this.toJSON(),\n      query,\n      parsedConfig.runId,\n      undefined,\n      undefined,\n      undefined,\n      parsedConfig.runName\n    );\n    try {\n      const results = await this._getRelevantDocuments(query, runManager);\n      await runManager?.handleRetrieverEnd(results);\n      return results;\n    } catch (error) {\n      await runManager?.handleRetrieverError(error);\n      throw error;\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAgFA,IAAsB,gBAAtB,cAIU,SAEV;;;;CAIE;;;;CAKA;;;;;CAMA;;;;CAKA;;;;;;;CAQA,YAAYA,QAA6B;EACvC,MAAM,OAAO;EACb,KAAK,YAAY,QAAQ;EACzB,KAAK,OAAO,QAAQ,QAAQ,CAAE;EAC9B,KAAK,WAAW,QAAQ,YAAY,CAAE;EACtC,KAAK,UAAU,QAAQ,WAAW;CACnC;;;;;;;;;;;;;;;;;;;;CAqBD,sBACEC,QACAC,YACwC;AACxC,QAAM,IAAI,MAAM;CACjB;;;;;;;;;;CAWD,MAAM,OACJC,OACAC,SACwC;AACxC,SAAO,KAAK,qBAAqB,OAAO,aAAa,QAAQ,CAAC;CAC/D;;;;;;;;;;;;;CAcD,MAAM,qBACJC,OACAC,QACwC;EACxC,MAAM,eAAe,aAAa,uBAAuB,OAAO,CAAC;EACjE,MAAM,mBAAmB,MAAM,gBAAgB,UAC7C,aAAa,WACb,KAAK,WACL,aAAa,MACb,KAAK,MACL,aAAa,UACb,KAAK,UACL,EAAE,SAAS,KAAK,QAAS,EAC1B;EACD,MAAM,aAAa,MAAM,kBAAkB,qBACzC,KAAK,QAAQ,EACb,OACA,aAAa,OACb,QACA,QACA,QACA,aAAa,QACd;AACD,MAAI;GACF,MAAM,UAAU,MAAM,KAAK,sBAAsB,OAAO,WAAW;GACnE,MAAM,YAAY,mBAAmB,QAAQ;AAC7C,UAAO;EACR,SAAQ,OAAO;GACd,MAAM,YAAY,qBAAqB,MAAM;AAC7C,SAAM;EACP;CACF;AACF"}
+{"version":3,"file":"index.js","names":["fields?: BaseRetrieverInput","_query: string","_callbacks?: CallbackManagerForRetrieverRun","input: string","options?: RunnableConfig"],"sources":["../../src/retrievers/index.ts"],"sourcesContent":["import {\n  CallbackManager,\n  CallbackManagerForRetrieverRun,\n  Callbacks,\n  parseCallbackConfigArg,\n} from \"../callbacks/manager.js\";\nimport type { DocumentInterface } from \"../documents/document.js\";\nimport { Runnable, type RunnableInterface } from \"../runnables/base.js\";\nimport { RunnableConfig, ensureConfig } from \"../runnables/config.js\";\n\n/**\n * Input configuration options for initializing a retriever that extends\n * the `BaseRetriever` class. This interface provides base properties\n * common to all retrievers, allowing customization of callback functions,\n * tagging, metadata, and logging verbosity.\n *\n * Fields:\n * - `callbacks` (optional): An array of callback functions that handle various\n *   events during retrieval, such as logging, error handling, or progress updates.\n *\n * - `tags` (optional): An array of strings used to add contextual tags to\n *   retrieval operations, allowing for easier categorization and tracking.\n *\n * - `metadata` (optional): A record of key-value pairs to store additional\n *   contextual information for retrieval operations, which can be useful\n *   for logging or auditing purposes.\n *\n * - `verbose` (optional): A boolean flag that, if set to `true`, enables\n *   detailed logging and output during the retrieval process. Defaults to `false`.\n */\nexport interface BaseRetrieverInput {\n  callbacks?: Callbacks;\n  tags?: string[];\n  metadata?: Record<string, unknown>;\n  verbose?: boolean;\n}\n\n/**\n * Interface for a base retriever that defines core functionality for\n * retrieving relevant documents from a source based on a query.\n *\n * The `BaseRetrieverInterface` standardizes the `getRelevantDocuments` method,\n * enabling retrieval of documents that match the query criteria.\n *\n * @template Metadata - The type of metadata associated with each document,\n *                      defaulting to `Record<string, any>`.\n */\nexport interface BaseRetrieverInterface<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  Metadata extends Record<string, any> = Record<string, any>\n> extends RunnableInterface<string, DocumentInterface<Metadata>[]> {}\n\n/**\n * Abstract base class for a document retrieval system, designed to\n * process string queries and return the most relevant documents from a source.\n *\n * `BaseRetriever` provides common properties and methods for derived retrievers,\n * such as callbacks, tagging, and verbose logging. Custom retrieval systems\n * should extend this class and implement `_getRelevantDocuments` to define\n * the specific retrieval logic.\n *\n * @template Metadata - The type of metadata associated with each document,\n *                      defaulting to `Record<string, any>`.\n */\nexport abstract class BaseRetriever<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Metadata extends Record<string, any> = Record<string, any>\n  >\n  extends Runnable<string, DocumentInterface<Metadata>[]>\n  implements BaseRetrieverInterface\n{\n  /**\n   * Optional callbacks to handle various events in the retrieval process.\n   */\n  callbacks?: Callbacks;\n\n  /**\n   * Tags to label or categorize the retrieval operation.\n   */\n  tags?: string[];\n\n  /**\n   * Metadata to provide additional context or information about the retrieval\n   * operation.\n   */\n  metadata?: Record<string, unknown>;\n\n  /**\n   * If set to `true`, enables verbose logging for the retrieval process.\n   */\n  verbose?: boolean;\n\n  /**\n   * Constructs a new `BaseRetriever` instance with optional configuration fields.\n   *\n   * @param fields - Optional input configuration that can include `callbacks`,\n   *                 `tags`, `metadata`, and `verbose` settings for custom retriever behavior.\n   */\n  constructor(fields?: BaseRetrieverInput) {\n    super(fields);\n    this.callbacks = fields?.callbacks;\n    this.tags = fields?.tags ?? [];\n    this.metadata = fields?.metadata ?? {};\n    this.verbose = fields?.verbose ?? false;\n  }\n\n  /**\n   * TODO: This should be an abstract method, but we'd like to avoid breaking\n   * changes to people currently using subclassed custom retrievers.\n   * Change it on next major release.\n   */\n  /**\n   * Placeholder method for retrieving relevant documents based on a query.\n   *\n   * This method is intended to be implemented by subclasses and will be\n   * converted to an abstract method in the next major release. Currently, it\n   * throws an error if not implemented, ensuring that custom retrievers define\n   * the specific retrieval logic.\n   *\n   * @param _query - The query string used to search for relevant documents.\n   * @param _callbacks - (optional) Callback manager for managing callbacks\n   *                     during retrieval.\n   * @returns A promise resolving to an array of `DocumentInterface` instances relevant to the query.\n   * @throws {Error} Throws an error indicating the method is not implemented.\n   */\n  _getRelevantDocuments(\n    _query: string,\n    _callbacks?: CallbackManagerForRetrieverRun\n  ): Promise<DocumentInterface<Metadata>[]> {\n    throw new Error(\"Not implemented!\");\n  }\n\n  /**\n   * Executes a retrieval operation.\n   *\n   * @param input - The query string used to search for relevant documents.\n   * @param options - (optional) Configuration options for the retrieval run,\n   *                  which may include callbacks, tags, and metadata.\n   * @returns A promise that resolves to an array of `DocumentInterface` instances\n   *          representing the most relevant documents to the query.\n   */\n  async invoke(\n    input: string,\n    options?: RunnableConfig\n  ): Promise<DocumentInterface<Metadata>[]> {\n    const parsedConfig = ensureConfig(parseCallbackConfigArg(options));\n    const callbackManager_ = await CallbackManager.configure(\n      parsedConfig.callbacks,\n      this.callbacks,\n      parsedConfig.tags,\n      this.tags,\n      parsedConfig.metadata,\n      this.metadata,\n      { verbose: this.verbose }\n    );\n    const runManager = await callbackManager_?.handleRetrieverStart(\n      this.toJSON(),\n      input,\n      parsedConfig.runId,\n      undefined,\n      undefined,\n      undefined,\n      parsedConfig.runName\n    );\n    try {\n      const results = await this._getRelevantDocuments(input, runManager);\n      await runManager?.handleRetrieverEnd(results);\n      return results;\n    } catch (error) {\n      await runManager?.handleRetrieverError(error);\n      throw error;\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAgEA,IAAsB,gBAAtB,cAIU,SAEV;;;;CAIE;;;;CAKA;;;;;CAMA;;;;CAKA;;;;;;;CAQA,YAAYA,QAA6B;EACvC,MAAM,OAAO;EACb,KAAK,YAAY,QAAQ;EACzB,KAAK,OAAO,QAAQ,QAAQ,CAAE;EAC9B,KAAK,WAAW,QAAQ,YAAY,CAAE;EACtC,KAAK,UAAU,QAAQ,WAAW;CACnC;;;;;;;;;;;;;;;;;;;;CAqBD,sBACEC,QACAC,YACwC;AACxC,QAAM,IAAI,MAAM;CACjB;;;;;;;;;;CAWD,MAAM,OACJC,OACAC,SACwC;EACxC,MAAM,eAAe,aAAa,uBAAuB,QAAQ,CAAC;EAClE,MAAM,mBAAmB,MAAM,gBAAgB,UAC7C,aAAa,WACb,KAAK,WACL,aAAa,MACb,KAAK,MACL,aAAa,UACb,KAAK,UACL,EAAE,SAAS,KAAK,QAAS,EAC1B;EACD,MAAM,aAAa,MAAM,kBAAkB,qBACzC,KAAK,QAAQ,EACb,OACA,aAAa,OACb,QACA,QACA,QACA,aAAa,QACd;AACD,MAAI;GACF,MAAM,UAAU,MAAM,KAAK,sBAAsB,OAAO,WAAW;GACnE,MAAM,YAAY,mBAAmB,QAAQ;AAC7C,UAAO;EACR,SAAQ,OAAO;GACd,MAAM,YAAY,qBAAqB,MAAM;AAC7C,SAAM;EACP;CACF;AACF"}

package/dist/runnables/base.cjs

@@ -36,29 +36,6 @@ var Runnable = class extends require_load_serializable.Serializable {
 		return suffix ? `${name}${suffix}` : name;
 	}
 	/**
-	* Bind arguments to a Runnable, returning a new Runnable.
-	* @param kwargs
-	* @returns A new RunnableBinding that, when invoked, will apply the bound args.
-	*
-	* @deprecated Use {@link withConfig} instead. This will be removed in the next breaking release.
-	*/
-	bind(kwargs) {
-		return new RunnableBinding({
-			bound: this,
-			kwargs,
-			config: {}
-		});
-	}
-	/**
-	* Return a new Runnable that maps a list of inputs to a list of outputs,
-	* by calling invoke() with each input.
-	*
-	* @deprecated This will be removed in the next breaking release.
-	*/
-	map() {
-		return new RunnableEach({ bound: this });
-	}
-	/**
 	* Add retry logic to an existing runnable.
 	* @param fields.stopAfterAttempt The number of attempts to retry.
 	* @param fields.onFailedAttempt A function that is called when a retry fails.
@@ -224,6 +201,10 @@ var Runnable = class extends require_load_serializable.Serializable {
 		await Promise.all(runManagers.map((runManager) => runManager?.handleChainEnd(_coerceToDict(outputs, "output"))));
 		return outputs;
 	}
+	/** @internal */
+	_concatOutputChunks(first, second) {
+		return require_utils_stream.concat(first, second);
+	}
 	/**
 	* Helper method to transform an Iterator of Input values into an Iterator of
 	* Output values, with callbacks.
@@ -236,11 +217,12 @@ var Runnable = class extends require_load_serializable.Serializable {
 		let finalOutputSupported = true;
 		const config = require_config.ensureConfig(options);
 		const callbackManager_ = await require_config.getCallbackManagerForConfig(config);
+		const outerThis = this;
 		async function* wrapInputForTracing() {
 			for await (const chunk of inputGenerator) {
 				if (finalInputSupported) if (finalInput === void 0) finalInput = chunk;
 				else try {
-					finalInput = require_utils_stream.concat(finalInput, chunk);
+					finalInput = outerThis._concatOutputChunks(finalInput, chunk);
 				} catch {
 					finalInput = void 0;
 					finalInputSupported = false;
@@ -262,7 +244,7 @@ var Runnable = class extends require_load_serializable.Serializable {
 				yield chunk;
 				if (finalOutputSupported) if (finalOutput === void 0) finalOutput = chunk;
 				else try {
-					finalOutput = require_utils_stream.concat(finalOutput, chunk);
+					finalOutput = this._concatOutputChunks(finalOutput, chunk);
 				} catch {
 					finalOutput = void 0;
 					finalOutputSupported = false;
@@ -323,7 +305,7 @@ var Runnable = class extends require_load_serializable.Serializable {
 	async *transform(generator, options) {
 		let finalChunk;
 		for await (const chunk of generator) if (finalChunk === void 0) finalChunk = chunk;
-		else finalChunk = require_utils_stream.concat(finalChunk, chunk);
+		else finalChunk = this._concatOutputChunks(finalChunk, chunk);
 		yield* this._streamIterator(finalChunk, require_config.ensureConfig(options));
 	}
 	/**
@@ -605,8 +587,8 @@ var Runnable = class extends require_load_serializable.Serializable {
 * const runnable = RunnableLambda.from(enhanceProfile);
 *
 * // Bind configuration to the runnable to set the user's role dynamically
-* const adminRunnable = runnable.bind({ configurable: { role: "Admin" } });
-* const userRunnable = runnable.bind({ configurable: { role: "User" } });
+* const adminRunnable = runnable.withConfig({ configurable: { role: "Admin" } });
+* const userRunnable = runnable.withConfig({ configurable: { role: "User" } });
 *
 * const result1 = await adminRunnable.invoke({
 *   name: "Alice",
@@ -647,23 +629,6 @@ var RunnableBinding = class RunnableBinding extends Runnable {
 		const config = require_config.mergeConfigs(this.config, ...options);
 		return require_config.mergeConfigs(config, ...this.configFactories ? await Promise.all(this.configFactories.map(async (configFactory) => await configFactory(config))) : []);
 	}
-	/**
-	* Binds the runnable with the specified arguments.
-	* @param kwargs The arguments to bind the runnable with.
-	* @returns A new instance of the `RunnableBinding` class that is bound with the specified arguments.
-	*
-	* @deprecated Use {@link withConfig} instead. This will be removed in the next breaking release.
-	*/
-	bind(kwargs) {
-		return new this.constructor({
-			bound: this.bound,
-			kwargs: {
-				...this.kwargs,
-				...kwargs
-			},
-			config: this.config
-		});
-	}
 	withConfig(config) {
 		return new this.constructor({
 			bound: this.bound,
@@ -684,12 +649,16 @@ var RunnableBinding = class RunnableBinding extends Runnable {
 		});
 	}
 	async invoke(input, options) {
-		return this.bound.invoke(input, await this._mergeConfig(require_config.ensureConfig(options), this.kwargs));
+		return this.bound.invoke(input, await this._mergeConfig(options, this.kwargs));
 	}
 	async batch(inputs, options, batchOptions) {
 		const mergedOptions = Array.isArray(options) ? await Promise.all(options.map(async (individualOption) => this._mergeConfig(require_config.ensureConfig(individualOption), this.kwargs))) : await this._mergeConfig(require_config.ensureConfig(options), this.kwargs);
 		return this.bound.batch(inputs, mergedOptions, batchOptions);
 	}
+	/** @internal */
+	_concatOutputChunks(first, second) {
+		return this.bound._concatOutputChunks(first, second);
+	}
 	async *_streamIterator(input, options) {
 		yield* this.bound._streamIterator(input, await this._mergeConfig(require_config.ensureConfig(options), this.kwargs));
 	}
@@ -758,8 +727,6 @@ var RunnableBinding = class RunnableBinding extends Runnable {
 *
 * // ["Hello, ALICE!", "Hello, BOB!", "Hello, CAROL!"]
 * ```
-*
-* @deprecated This will be removed in the next breaking release.
 */
 var RunnableEach = class RunnableEach extends Runnable {
 	static lc_name() {
@@ -773,16 +740,6 @@ var RunnableEach = class RunnableEach extends Runnable {
 		this.bound = fields.bound;
 	}
 	/**
-	* Binds the runnable with the specified arguments.
-	* @param kwargs The arguments to bind the runnable with.
-	* @returns A new instance of the `RunnableEach` class that is bound with the specified arguments.
-	*
-	* @deprecated Use {@link withConfig} instead. This will be removed in the next breaking release.
-	*/
-	bind(kwargs) {
-		return new RunnableEach({ bound: this.bound.bind(kwargs) });
-	}
-	/**
 	* Invokes the runnable with the specified input and configuration.
 	* @param input The input to invoke the runnable with.
 	* @param config The configuration to invoke the runnable with.
@@ -1021,6 +978,10 @@ var RunnableSequence = class RunnableSequence extends Runnable {
 		await Promise.all(runManagers.map((runManager) => runManager?.handleChainEnd(_coerceToDict(nextStepInputs, "output"))));
 		return nextStepInputs;
 	}
+	/** @internal */
+	_concatOutputChunks(first, second) {
+		return this.last._concatOutputChunks(first, second);
+	}
 	async *_streamIterator(input, options) {
 		const callbackManager_ = await require_config.getCallbackManagerForConfig(options);
 		const { runId,...otherOptions } = options ?? {};
@@ -1046,7 +1007,7 @@ var RunnableSequence = class RunnableSequence extends Runnable {
 				yield chunk;
 				if (concatSupported) if (finalOutput === void 0) finalOutput = chunk;
 				else try {
-					finalOutput = require_utils_stream.concat(finalOutput, chunk);
+					finalOutput = this._concatOutputChunks(finalOutput, chunk);
 				} catch {
 					finalOutput = void 0;
 					concatSupported = false;
@@ -1307,7 +1268,7 @@ var RunnableLambda = class RunnableLambda extends Runnable {
 							config?.signal?.throwIfAborted();
 							if (finalOutput === void 0) finalOutput = chunk;
 							else try {
-								finalOutput = require_utils_stream.concat(finalOutput, chunk);
+								finalOutput = this._concatOutputChunks(finalOutput, chunk);
 							} catch {
 								finalOutput = chunk;
 							}
@@ -1319,7 +1280,7 @@ var RunnableLambda = class RunnableLambda extends Runnable {
 							config?.signal?.throwIfAborted();
 							if (finalOutput === void 0) finalOutput = chunk;
 							else try {
-								finalOutput = require_utils_stream.concat(finalOutput, chunk);
+								finalOutput = this._concatOutputChunks(finalOutput, chunk);
 							} catch {
 								finalOutput = chunk;
 							}
@@ -1340,7 +1301,7 @@ var RunnableLambda = class RunnableLambda extends Runnable {
 		let finalChunk;
 		for await (const chunk of generator) if (finalChunk === void 0) finalChunk = chunk;
 		else try {
-			finalChunk = require_utils_stream.concat(finalChunk, chunk);
+			finalChunk = this._concatOutputChunks(finalChunk, chunk);
 		} catch {
 			finalChunk = chunk;
 		}
@@ -1562,7 +1523,7 @@ var RunnableWithFallbacks = class extends Runnable {
 			for await (const chunk of stream) {
 				yield chunk;
 				try {
-					output = output === void 0 ? output : require_utils_stream.concat(output, chunk);
+					output = output === void 0 ? output : this._concatOutputChunks(output, chunk);
 				} catch {
 					output = void 0;
 				}