@langchain/classic 1.0.0-alpha.1

package/dist/experimental/openai_files/index.d.cts

@@ -0,0 +1,105 @@
+import { Serializable } from "@langchain/core/load/serializable";
+import { ClientOptions, OpenAIClient } from "@langchain/openai";
+
+//#region src/experimental/openai_files/index.d.ts
+type OpenAIFilesInput = {
+  client?: OpenAIClient;
+  clientOptions?: ClientOptions;
+};
+declare class OpenAIFiles extends Serializable {
+  lc_namespace: string[];
+  private oaiClient;
+  constructor(fields?: OpenAIFilesInput);
+  /**
+   * Upload file
+   * Upload a file that can be used across various endpoints. The size of all the files uploaded by one organization can be up to 100 GB.
+   *
+   * @note The size of individual files can be a maximum of 512 MB. See the Assistants Tools guide to learn more about the types of files supported. The Fine-tuning API only supports .jsonl files.
+   *
+   * @link {https://platform.openai.com/docs/api-reference/files/create}
+   * @param {OpenAIClient.FileCreateParams['file']} file
+   * @param {OpenAIClient.FileCreateParams['purpose']} purpose
+   * @param {OpenAIClient.RequestOptions | undefined} options
+   * @returns {Promise<OpenAIClient.Files.FileObject>}
+   */
+  createFile({
+    file,
+    purpose,
+    options
+  }: OpenAIClient.FileCreateParams & {
+    options?: OpenAIClient.RequestOptions;
+  }): Promise<OpenAIClient.FileObject & {
+    _request_id?: string | null | undefined;
+  }>;
+  /**
+   * Delete a file.
+   *
+   * @link {https://platform.openai.com/docs/api-reference/files/delete}
+   * @param {string} fileId
+   * @param {OpenAIClient.RequestOptions | undefined} options
+   * @returns {Promise<OpenAIClient.Files.FileDeleted>}
+   */
+  deleteFile({
+    fileId,
+    options
+  }: {
+    fileId: string;
+    options?: OpenAIClient.RequestOptions;
+  }): Promise<OpenAIClient.FileDeleted & {
+    _request_id?: string | null | undefined;
+  }>;
+  /**
+   * List files
+   * Returns a list of files that belong to the user's organization.
+   *
+   * @link {https://platform.openai.com/docs/api-reference/files/list}
+   * @param {OpenAIClient.Files.FileListParams | undefined} query
+   * @param {OpenAIClient.RequestOptions | undefined} options
+   * @returns {Promise<OpenAIClient.Files.FileObjectsPage>}
+   */
+  listFiles(props?: {
+    query?: OpenAIClient.Files.FileListParams;
+    options?: OpenAIClient.RequestOptions;
+  }): Promise<OpenAIClient.FileObjectsPage>;
+  /**
+   * Retrieve file
+   * Returns information about a specific file.
+   *
+   * @link {https://platform.openai.com/docs/api-reference/files/retrieve}
+   * @param {string} fileId
+   * @param {OpenAIClient.RequestOptions | undefined} options
+   * @returns {Promise<OpenAIClient.Files.FileObject>}
+   */
+  retrieveFile({
+    fileId,
+    options
+  }: {
+    fileId: string;
+    options?: OpenAIClient.RequestOptions;
+  }): Promise<OpenAIClient.FileObject & {
+    _request_id?: string | null | undefined;
+  }>;
+  /**
+   * Retrieve file content
+   * Returns the contents of the specified file.
+   *
+   * @note You can't retrieve the contents of a file that was uploaded with the "purpose": "assistants" API.
+   *
+   * @link {https://platform.openai.com/docs/api-reference/files/retrieve-contents}
+   * @param {string} fileId
+   * @param {OpenAIClient.RequestOptions | undefined} options
+   * @returns {Promise<string>}
+   */
+  retrieveFileContent({
+    fileId,
+    options
+  }: {
+    fileId: string;
+    options?: OpenAIClient.RequestOptions;
+  }): Promise<OpenAIClient.FileObject & {
+    _request_id?: string | null | undefined;
+  }>;
+}
+//#endregion
+export { OpenAIFiles, OpenAIFilesInput };
+//# sourceMappingURL=index.d.cts.map

package/dist/experimental/openai_files/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["OpenAIClient","ClientOptions","Serializable","OpenAIFilesInput","OpenAIFiles","file","purpose","options","FileCreateParams","RequestOptions","FileObject","Promise","fileId","FileDeleted","Files","FileListParams","FileObjectsPage"],"sources":["../../../src/experimental/openai_files/index.d.ts"],"sourcesContent":["import { OpenAIClient, type ClientOptions } from \"@langchain/openai\";\nimport { Serializable } from \"@langchain/core/load/serializable\";\nexport type OpenAIFilesInput = {\n    client?: OpenAIClient;\n    clientOptions?: ClientOptions;\n};\nexport declare class OpenAIFiles extends Serializable {\n    lc_namespace: string[];\n    private oaiClient;\n    constructor(fields?: OpenAIFilesInput);\n    /**\n     * Upload file\n     * Upload a file that can be used across various endpoints. The size of all the files uploaded by one organization can be up to 100 GB.\n     *\n     * @note The size of individual files can be a maximum of 512 MB. See the Assistants Tools guide to learn more about the types of files supported. The Fine-tuning API only supports .jsonl files.\n     *\n     * @link {https://platform.openai.com/docs/api-reference/files/create}\n     * @param {OpenAIClient.FileCreateParams['file']} file\n     * @param {OpenAIClient.FileCreateParams['purpose']} purpose\n     * @param {OpenAIClient.RequestOptions | undefined} options\n     * @returns {Promise<OpenAIClient.Files.FileObject>}\n     */\n    createFile({ file, purpose, options }: OpenAIClient.FileCreateParams & {\n        options?: OpenAIClient.RequestOptions;\n    }): Promise<OpenAIClient.FileObject & {\n        _request_id?: string | null | undefined;\n    }>;\n    /**\n     * Delete a file.\n     *\n     * @link {https://platform.openai.com/docs/api-reference/files/delete}\n     * @param {string} fileId\n     * @param {OpenAIClient.RequestOptions | undefined} options\n     * @returns {Promise<OpenAIClient.Files.FileDeleted>}\n     */\n    deleteFile({ fileId, options }: {\n        fileId: string;\n        options?: OpenAIClient.RequestOptions;\n    }): Promise<OpenAIClient.FileDeleted & {\n        _request_id?: string | null | undefined;\n    }>;\n    /**\n     * List files\n     * Returns a list of files that belong to the user's organization.\n     *\n     * @link {https://platform.openai.com/docs/api-reference/files/list}\n     * @param {OpenAIClient.Files.FileListParams | undefined} query\n     * @param {OpenAIClient.RequestOptions | undefined} options\n     * @returns {Promise<OpenAIClient.Files.FileObjectsPage>}\n     */\n    listFiles(props?: {\n        query?: OpenAIClient.Files.FileListParams;\n        options?: OpenAIClient.RequestOptions;\n    }): Promise<OpenAIClient.FileObjectsPage>;\n    /**\n     * Retrieve file\n     * Returns information about a specific file.\n     *\n     * @link {https://platform.openai.com/docs/api-reference/files/retrieve}\n     * @param {string} fileId\n     * @param {OpenAIClient.RequestOptions | undefined} options\n     * @returns {Promise<OpenAIClient.Files.FileObject>}\n     */\n    retrieveFile({ fileId, options }: {\n        fileId: string;\n        options?: OpenAIClient.RequestOptions;\n    }): Promise<OpenAIClient.FileObject & {\n        _request_id?: string | null | undefined;\n    }>;\n    /**\n     * Retrieve file content\n     * Returns the contents of the specified file.\n     *\n     * @note You can't retrieve the contents of a file that was uploaded with the \"purpose\": \"assistants\" API.\n     *\n     * @link {https://platform.openai.com/docs/api-reference/files/retrieve-contents}\n     * @param {string} fileId\n     * @param {OpenAIClient.RequestOptions | undefined} options\n     * @returns {Promise<string>}\n     */\n    retrieveFileContent({ fileId, options }: {\n        fileId: string;\n        options?: OpenAIClient.RequestOptions;\n    }): Promise<OpenAIClient.FileObject & {\n        _request_id?: string | null | undefined;\n    }>;\n}\n"],"mappings":";;;;KAEYG,gBAAAA;WACCH;EADDG,aAAAA,CAAAA,EAEQF,aAFQ;CAAA;AACfD,cAGQI,WAAAA,SAAoBF,YAAAA,CAH5BF;EAAY,YACLC,EAAAA,MAAAA,EAAAA;EAAa,QAAA,SAAA;EAEZG,WAAAA,CAAAA,MAAW,CAAA,EAGPD,gBAHO;EAAA;;;;;;;;;;;;EA+Ba,UAC7BH,CAAAA;IAAAA,IAAaa;IAAAA,OAAAA;IAAAA;EAAd,CAAcA,EAhBcb,YAAAA,CAAaQ,gBAgB3BK,GAAAA;IAArBF,OAAAA,CAAAA,EAfUX,YAAAA,CAAaS,cAevBE;EAAO,CAAA,CAAA,EAdPA,OA2BQX,CA3BAA,YAAAA,CAAaU,UA2BMK,GAAAA;IACjBf,WAAAA,CAAaS,EAAAA,MAAAA,GAAAA,IAAAA,GAAAA,SAAAA;EAAc,CAAA,CAAA;EACD;;;;;;;;EA2BH,UAEvBT,CAAAA;IAAAA,MAAaS;IAAAA;EAChB,CADgBA,EAAAA;IACfT,MAAAA,EAAAA,MAAaU;IAArBC,OAAAA,CAAAA,EA9CUX,YAAAA,CAAaS,cA8CvBE;EAAO,CAAA,CAAA,EA7CPA,OAhCiCT,CAgCzBF,YAAAA,CAAaa,WAhCYX,GAAAA;IAAY,WAAA,CAAA,EAAA,MAAA,GAAA,IAAA,GAAA,SAAA;;;;;;;;;;;;YA6CrCF,YAAAA,CAAac,KAAAA,CAAMC;cACjBf,YAAAA,CAAaS;MACvBE,QAAQX,YAAAA,CAAagB;;;;;;;;;;;;;;;cAYXhB,YAAAA,CAAaS;MACvBE,QAAQX,YAAAA,CAAaU;;;;;;;;;;;;;;;;;;;cAgBXV,YAAAA,CAAaS;MACvBE,QAAQX,YAAAA,CAAaU"}

package/dist/experimental/openai_files/index.d.ts

@@ -0,0 +1,105 @@
+import { Serializable } from "@langchain/core/load/serializable";
+import { ClientOptions, OpenAIClient } from "@langchain/openai";
+
+//#region src/experimental/openai_files/index.d.ts
+type OpenAIFilesInput = {
+  client?: OpenAIClient;
+  clientOptions?: ClientOptions;
+};
+declare class OpenAIFiles extends Serializable {
+  lc_namespace: string[];
+  private oaiClient;
+  constructor(fields?: OpenAIFilesInput);
+  /**
+   * Upload file
+   * Upload a file that can be used across various endpoints. The size of all the files uploaded by one organization can be up to 100 GB.
+   *
+   * @note The size of individual files can be a maximum of 512 MB. See the Assistants Tools guide to learn more about the types of files supported. The Fine-tuning API only supports .jsonl files.
+   *
+   * @link {https://platform.openai.com/docs/api-reference/files/create}
+   * @param {OpenAIClient.FileCreateParams['file']} file
+   * @param {OpenAIClient.FileCreateParams['purpose']} purpose
+   * @param {OpenAIClient.RequestOptions | undefined} options
+   * @returns {Promise<OpenAIClient.Files.FileObject>}
+   */
+  createFile({
+    file,
+    purpose,
+    options
+  }: OpenAIClient.FileCreateParams & {
+    options?: OpenAIClient.RequestOptions;
+  }): Promise<OpenAIClient.FileObject & {
+    _request_id?: string | null | undefined;
+  }>;
+  /**
+   * Delete a file.
+   *
+   * @link {https://platform.openai.com/docs/api-reference/files/delete}
+   * @param {string} fileId
+   * @param {OpenAIClient.RequestOptions | undefined} options
+   * @returns {Promise<OpenAIClient.Files.FileDeleted>}
+   */
+  deleteFile({
+    fileId,
+    options
+  }: {
+    fileId: string;
+    options?: OpenAIClient.RequestOptions;
+  }): Promise<OpenAIClient.FileDeleted & {
+    _request_id?: string | null | undefined;
+  }>;
+  /**
+   * List files
+   * Returns a list of files that belong to the user's organization.
+   *
+   * @link {https://platform.openai.com/docs/api-reference/files/list}
+   * @param {OpenAIClient.Files.FileListParams | undefined} query
+   * @param {OpenAIClient.RequestOptions | undefined} options
+   * @returns {Promise<OpenAIClient.Files.FileObjectsPage>}
+   */
+  listFiles(props?: {
+    query?: OpenAIClient.Files.FileListParams;
+    options?: OpenAIClient.RequestOptions;
+  }): Promise<OpenAIClient.FileObjectsPage>;
+  /**
+   * Retrieve file
+   * Returns information about a specific file.
+   *
+   * @link {https://platform.openai.com/docs/api-reference/files/retrieve}
+   * @param {string} fileId
+   * @param {OpenAIClient.RequestOptions | undefined} options
+   * @returns {Promise<OpenAIClient.Files.FileObject>}
+   */
+  retrieveFile({
+    fileId,
+    options
+  }: {
+    fileId: string;
+    options?: OpenAIClient.RequestOptions;
+  }): Promise<OpenAIClient.FileObject & {
+    _request_id?: string | null | undefined;
+  }>;
+  /**
+   * Retrieve file content
+   * Returns the contents of the specified file.
+   *
+   * @note You can't retrieve the contents of a file that was uploaded with the "purpose": "assistants" API.
+   *
+   * @link {https://platform.openai.com/docs/api-reference/files/retrieve-contents}
+   * @param {string} fileId
+   * @param {OpenAIClient.RequestOptions | undefined} options
+   * @returns {Promise<string>}
+   */
+  retrieveFileContent({
+    fileId,
+    options
+  }: {
+    fileId: string;
+    options?: OpenAIClient.RequestOptions;
+  }): Promise<OpenAIClient.FileObject & {
+    _request_id?: string | null | undefined;
+  }>;
+}
+//#endregion
+export { OpenAIFiles, OpenAIFilesInput };
+//# sourceMappingURL=index.d.ts.map

package/dist/experimental/openai_files/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["OpenAIClient","ClientOptions","Serializable","OpenAIFilesInput","OpenAIFiles","file","purpose","options","FileCreateParams","RequestOptions","FileObject","Promise","fileId","FileDeleted","Files","FileListParams","FileObjectsPage"],"sources":["../../../src/experimental/openai_files/index.d.ts"],"sourcesContent":["import { OpenAIClient, type ClientOptions } from \"@langchain/openai\";\nimport { Serializable } from \"@langchain/core/load/serializable\";\nexport type OpenAIFilesInput = {\n    client?: OpenAIClient;\n    clientOptions?: ClientOptions;\n};\nexport declare class OpenAIFiles extends Serializable {\n    lc_namespace: string[];\n    private oaiClient;\n    constructor(fields?: OpenAIFilesInput);\n    /**\n     * Upload file\n     * Upload a file that can be used across various endpoints. The size of all the files uploaded by one organization can be up to 100 GB.\n     *\n     * @note The size of individual files can be a maximum of 512 MB. See the Assistants Tools guide to learn more about the types of files supported. The Fine-tuning API only supports .jsonl files.\n     *\n     * @link {https://platform.openai.com/docs/api-reference/files/create}\n     * @param {OpenAIClient.FileCreateParams['file']} file\n     * @param {OpenAIClient.FileCreateParams['purpose']} purpose\n     * @param {OpenAIClient.RequestOptions | undefined} options\n     * @returns {Promise<OpenAIClient.Files.FileObject>}\n     */\n    createFile({ file, purpose, options }: OpenAIClient.FileCreateParams & {\n        options?: OpenAIClient.RequestOptions;\n    }): Promise<OpenAIClient.FileObject & {\n        _request_id?: string | null | undefined;\n    }>;\n    /**\n     * Delete a file.\n     *\n     * @link {https://platform.openai.com/docs/api-reference/files/delete}\n     * @param {string} fileId\n     * @param {OpenAIClient.RequestOptions | undefined} options\n     * @returns {Promise<OpenAIClient.Files.FileDeleted>}\n     */\n    deleteFile({ fileId, options }: {\n        fileId: string;\n        options?: OpenAIClient.RequestOptions;\n    }): Promise<OpenAIClient.FileDeleted & {\n        _request_id?: string | null | undefined;\n    }>;\n    /**\n     * List files\n     * Returns a list of files that belong to the user's organization.\n     *\n     * @link {https://platform.openai.com/docs/api-reference/files/list}\n     * @param {OpenAIClient.Files.FileListParams | undefined} query\n     * @param {OpenAIClient.RequestOptions | undefined} options\n     * @returns {Promise<OpenAIClient.Files.FileObjectsPage>}\n     */\n    listFiles(props?: {\n        query?: OpenAIClient.Files.FileListParams;\n        options?: OpenAIClient.RequestOptions;\n    }): Promise<OpenAIClient.FileObjectsPage>;\n    /**\n     * Retrieve file\n     * Returns information about a specific file.\n     *\n     * @link {https://platform.openai.com/docs/api-reference/files/retrieve}\n     * @param {string} fileId\n     * @param {OpenAIClient.RequestOptions | undefined} options\n     * @returns {Promise<OpenAIClient.Files.FileObject>}\n     */\n    retrieveFile({ fileId, options }: {\n        fileId: string;\n        options?: OpenAIClient.RequestOptions;\n    }): Promise<OpenAIClient.FileObject & {\n        _request_id?: string | null | undefined;\n    }>;\n    /**\n     * Retrieve file content\n     * Returns the contents of the specified file.\n     *\n     * @note You can't retrieve the contents of a file that was uploaded with the \"purpose\": \"assistants\" API.\n     *\n     * @link {https://platform.openai.com/docs/api-reference/files/retrieve-contents}\n     * @param {string} fileId\n     * @param {OpenAIClient.RequestOptions | undefined} options\n     * @returns {Promise<string>}\n     */\n    retrieveFileContent({ fileId, options }: {\n        fileId: string;\n        options?: OpenAIClient.RequestOptions;\n    }): Promise<OpenAIClient.FileObject & {\n        _request_id?: string | null | undefined;\n    }>;\n}\n"],"mappings":";;;;KAEYG,gBAAAA;WACCH;EADDG,aAAAA,CAAAA,EAEQF,aAFQ;CAAA;AACfD,cAGQI,WAAAA,SAAoBF,YAAAA,CAH5BF;EAAY,YACLC,EAAAA,MAAAA,EAAAA;EAAa,QAAA,SAAA;EAEZG,WAAAA,CAAAA,MAAW,CAAA,EAGPD,gBAHO;EAAA;;;;;;;;;;;;EA+Ba,UAC7BH,CAAAA;IAAAA,IAAaa;IAAAA,OAAAA;IAAAA;EAAd,CAAcA,EAhBcb,YAAAA,CAAaQ,gBAgB3BK,GAAAA;IAArBF,OAAAA,CAAAA,EAfUX,YAAAA,CAAaS,cAevBE;EAAO,CAAA,CAAA,EAdPA,OA2BQX,CA3BAA,YAAAA,CAAaU,UA2BMK,GAAAA;IACjBf,WAAAA,CAAaS,EAAAA,MAAAA,GAAAA,IAAAA,GAAAA,SAAAA;EAAc,CAAA,CAAA;EACD;;;;;;;;EA2BH,UAEvBT,CAAAA;IAAAA,MAAaS;IAAAA;EAChB,CADgBA,EAAAA;IACfT,MAAAA,EAAAA,MAAaU;IAArBC,OAAAA,CAAAA,EA9CUX,YAAAA,CAAaS,cA8CvBE;EAAO,CAAA,CAAA,EA7CPA,OAhCiCT,CAgCzBF,YAAAA,CAAaa,WAhCYX,GAAAA;IAAY,WAAA,CAAA,EAAA,MAAA,GAAA,IAAA,GAAA,SAAA;;;;;;;;;;;;YA6CrCF,YAAAA,CAAac,KAAAA,CAAMC;cACjBf,YAAAA,CAAaS;MACvBE,QAAQX,YAAAA,CAAagB;;;;;;;;;;;;;;;cAYXhB,YAAAA,CAAaS;MACvBE,QAAQX,YAAAA,CAAaU;;;;;;;;;;;;;;;;;;;cAgBXV,YAAAA,CAAaS;MACvBE,QAAQX,YAAAA,CAAaU"}

package/dist/experimental/openai_files/index.js

@@ -0,0 +1,86 @@
+import { __export } from "../../_virtual/rolldown_runtime.js";
+import { Serializable } from "@langchain/core/load/serializable";
+import { OpenAIClient } from "@langchain/openai";
+
+//#region src/experimental/openai_files/index.ts
+var openai_files_exports = {};
+__export(openai_files_exports, { OpenAIFiles: () => OpenAIFiles });
+var OpenAIFiles = class extends Serializable {
+	lc_namespace = ["langchain", "experimental"];
+	oaiClient;
+	constructor(fields) {
+		super(fields);
+		this.oaiClient = fields?.client ?? new OpenAIClient(fields?.clientOptions);
+	}
+	/**
+	* Upload file
+	* Upload a file that can be used across various endpoints. The size of all the files uploaded by one organization can be up to 100 GB.
+	*
+	* @note The size of individual files can be a maximum of 512 MB. See the Assistants Tools guide to learn more about the types of files supported. The Fine-tuning API only supports .jsonl files.
+	*
+	* @link {https://platform.openai.com/docs/api-reference/files/create}
+	* @param {OpenAIClient.FileCreateParams['file']} file
+	* @param {OpenAIClient.FileCreateParams['purpose']} purpose
+	* @param {OpenAIClient.RequestOptions | undefined} options
+	* @returns {Promise<OpenAIClient.Files.FileObject>}
+	*/
+	async createFile({ file, purpose, options }) {
+		return this.oaiClient.files.create({
+			file,
+			purpose
+		}, options);
+	}
+	/**
+	* Delete a file.
+	*
+	* @link {https://platform.openai.com/docs/api-reference/files/delete}
+	* @param {string} fileId
+	* @param {OpenAIClient.RequestOptions | undefined} options
+	* @returns {Promise<OpenAIClient.Files.FileDeleted>}
+	*/
+	async deleteFile({ fileId, options }) {
+		return this.oaiClient.files.delete(fileId, options);
+	}
+	/**
+	* List files
+	* Returns a list of files that belong to the user's organization.
+	*
+	* @link {https://platform.openai.com/docs/api-reference/files/list}
+	* @param {OpenAIClient.Files.FileListParams | undefined} query
+	* @param {OpenAIClient.RequestOptions | undefined} options
+	* @returns {Promise<OpenAIClient.Files.FileObjectsPage>}
+	*/
+	async listFiles(props) {
+		return this.oaiClient.files.list(props?.query, props?.options);
+	}
+	/**
+	* Retrieve file
+	* Returns information about a specific file.
+	*
+	* @link {https://platform.openai.com/docs/api-reference/files/retrieve}
+	* @param {string} fileId
+	* @param {OpenAIClient.RequestOptions | undefined} options
+	* @returns {Promise<OpenAIClient.Files.FileObject>}
+	*/
+	async retrieveFile({ fileId, options }) {
+		return this.oaiClient.files.retrieve(fileId, options);
+	}
+	/**
+	* Retrieve file content
+	* Returns the contents of the specified file.
+	*
+	* @note You can't retrieve the contents of a file that was uploaded with the "purpose": "assistants" API.
+	*
+	* @link {https://platform.openai.com/docs/api-reference/files/retrieve-contents}
+	* @param {string} fileId
+	* @param {OpenAIClient.RequestOptions | undefined} options
+	* @returns {Promise<string>}
+	*/
+	async retrieveFileContent({ fileId, options }) {
+		return this.oaiClient.files.retrieve(fileId, options);
+	}
+};
+
+//#endregion
+export { OpenAIFiles, openai_files_exports };
+//# sourceMappingURL=index.js.map

package/dist/experimental/openai_files/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["fields?: OpenAIFilesInput","props?: {\n    query?: OpenAIClient.Files.FileListParams;\n    options?: OpenAIClient.RequestOptions;\n  }"],"sources":["../../../src/experimental/openai_files/index.ts"],"sourcesContent":["import { OpenAIClient, type ClientOptions } from \"@langchain/openai\";\nimport { Serializable } from \"@langchain/core/load/serializable\";\n\nexport type OpenAIFilesInput = {\n  client?: OpenAIClient;\n  clientOptions?: ClientOptions;\n};\n\nexport class OpenAIFiles extends Serializable {\n  lc_namespace = [\"langchain\", \"experimental\"];\n\n  private oaiClient: OpenAIClient;\n\n  constructor(fields?: OpenAIFilesInput) {\n    super(fields);\n    this.oaiClient = fields?.client ?? new OpenAIClient(fields?.clientOptions);\n  }\n\n  /**\n   * Upload file\n   * Upload a file that can be used across various endpoints. The size of all the files uploaded by one organization can be up to 100 GB.\n   *\n   * @note The size of individual files can be a maximum of 512 MB. See the Assistants Tools guide to learn more about the types of files supported. The Fine-tuning API only supports .jsonl files.\n   *\n   * @link {https://platform.openai.com/docs/api-reference/files/create}\n   * @param {OpenAIClient.FileCreateParams['file']} file\n   * @param {OpenAIClient.FileCreateParams['purpose']} purpose\n   * @param {OpenAIClient.RequestOptions | undefined} options\n   * @returns {Promise<OpenAIClient.Files.FileObject>}\n   */\n  async createFile({\n    file,\n    purpose,\n    options,\n  }: OpenAIClient.FileCreateParams & {\n    options?: OpenAIClient.RequestOptions;\n  }) {\n    return this.oaiClient.files.create({ file, purpose }, options);\n  }\n\n  /**\n   * Delete a file.\n   *\n   * @link {https://platform.openai.com/docs/api-reference/files/delete}\n   * @param {string} fileId\n   * @param {OpenAIClient.RequestOptions | undefined} options\n   * @returns {Promise<OpenAIClient.Files.FileDeleted>}\n   */\n  async deleteFile({\n    fileId,\n    options,\n  }: {\n    fileId: string;\n    options?: OpenAIClient.RequestOptions;\n  }) {\n    return this.oaiClient.files.delete(fileId, options);\n  }\n\n  /**\n   * List files\n   * Returns a list of files that belong to the user's organization.\n   *\n   * @link {https://platform.openai.com/docs/api-reference/files/list}\n   * @param {OpenAIClient.Files.FileListParams | undefined} query\n   * @param {OpenAIClient.RequestOptions | undefined} options\n   * @returns {Promise<OpenAIClient.Files.FileObjectsPage>}\n   */\n  async listFiles(props?: {\n    query?: OpenAIClient.Files.FileListParams;\n    options?: OpenAIClient.RequestOptions;\n  }) {\n    return this.oaiClient.files.list(props?.query, props?.options);\n  }\n\n  /**\n   * Retrieve file\n   * Returns information about a specific file.\n   *\n   * @link {https://platform.openai.com/docs/api-reference/files/retrieve}\n   * @param {string} fileId\n   * @param {OpenAIClient.RequestOptions | undefined} options\n   * @returns {Promise<OpenAIClient.Files.FileObject>}\n   */\n  async retrieveFile({\n    fileId,\n    options,\n  }: {\n    fileId: string;\n    options?: OpenAIClient.RequestOptions;\n  }) {\n    return this.oaiClient.files.retrieve(fileId, options);\n  }\n\n  /**\n   * Retrieve file content\n   * Returns the contents of the specified file.\n   *\n   * @note You can't retrieve the contents of a file that was uploaded with the \"purpose\": \"assistants\" API.\n   *\n   * @link {https://platform.openai.com/docs/api-reference/files/retrieve-contents}\n   * @param {string} fileId\n   * @param {OpenAIClient.RequestOptions | undefined} options\n   * @returns {Promise<string>}\n   */\n  async retrieveFileContent({\n    fileId,\n    options,\n  }: {\n    fileId: string;\n    options?: OpenAIClient.RequestOptions;\n  }) {\n    return this.oaiClient.files.retrieve(fileId, options);\n  }\n}\n"],"mappings":";;;;;;;AAQA,IAAa,cAAb,cAAiC,aAAa;CAC5C,eAAe,CAAC,aAAa,cAAe;CAE5C,AAAQ;CAER,YAAYA,QAA2B;EACrC,MAAM,OAAO;EACb,KAAK,YAAY,QAAQ,UAAU,IAAI,aAAa,QAAQ;CAC7D;;;;;;;;;;;;;CAcD,MAAM,WAAW,EACf,MACA,SACA,SAGD,EAAE;AACD,SAAO,KAAK,UAAU,MAAM,OAAO;GAAE;GAAM;EAAS,GAAE,QAAQ;CAC/D;;;;;;;;;CAUD,MAAM,WAAW,EACf,QACA,SAID,EAAE;AACD,SAAO,KAAK,UAAU,MAAM,OAAO,QAAQ,QAAQ;CACpD;;;;;;;;;;CAWD,MAAM,UAAUC,OAGb;AACD,SAAO,KAAK,UAAU,MAAM,KAAK,OAAO,OAAO,OAAO,QAAQ;CAC/D;;;;;;;;;;CAWD,MAAM,aAAa,EACjB,QACA,SAID,EAAE;AACD,SAAO,KAAK,UAAU,MAAM,SAAS,QAAQ,QAAQ;CACtD;;;;;;;;;;;;CAaD,MAAM,oBAAoB,EACxB,QACA,SAID,EAAE;AACD,SAAO,KAAK,UAAU,MAAM,SAAS,QAAQ,QAAQ;CACtD;AACF"}

package/dist/experimental/plan_and_execute/agent_executor.cjs

@@ -0,0 +1,144 @@
+const require_base = require('../../chains/base.cjs');
+const require_llm_chain = require('../../chains/llm_chain.cjs');
+const require_executor = require('../../agents/executor.cjs');
+const require_index = require('../../agents/chat/index.cjs');
+const require_index$1 = require('../../agents/structured_chat/index.cjs');
+require('../../agents/index.cjs');
+const require_base$1 = require('./base.cjs');
+const require_prompt = require('./prompt.cjs');
+const require_outputParser = require('./outputParser.cjs');
+
+//#region src/experimental/plan_and_execute/agent_executor.ts
+/**
+* A utility function to distiguish a dynamicstructuredtool over other tools.
+* @param tool the tool to test
+* @returns bool
+*/
+function isDynamicStructuredTool(tool) {
+	return typeof tool.constructor.lc_name === "function" && tool.constructor.lc_name() === "DynamicStructuredTool";
+}
+/**
+* Class representing a plan-and-execute agent executor. This agent
+* decides on the full sequence of actions upfront, then executes them all
+* without updating the plan. This is suitable for complex or long-running
+* tasks that require maintaining long-term objectives and focus.
+*/
+var PlanAndExecuteAgentExecutor = class PlanAndExecuteAgentExecutor extends require_base.BaseChain {
+	static lc_name() {
+		return "PlanAndExecuteAgentExecutor";
+	}
+	planner;
+	stepExecutor;
+	stepContainer = new require_base$1.ListStepContainer();
+	inputKey = "input";
+	outputKey = "output";
+	constructor(input) {
+		super(input);
+		this.planner = input.planner;
+		this.stepExecutor = input.stepExecutor;
+		this.stepContainer = input.stepContainer ?? this.stepContainer;
+		this.inputKey = input.inputKey ?? this.inputKey;
+		this.outputKey = input.outputKey ?? this.outputKey;
+	}
+	get inputKeys() {
+		return [this.inputKey];
+	}
+	get outputKeys() {
+		return [this.outputKey];
+	}
+	/**
+	* Static method that returns a default planner for the agent. It creates
+	* a new LLMChain with a given LLM and a fixed prompt, and uses it to
+	* create a new LLMPlanner with a PlanOutputParser.
+	* @param llm The Large Language Model (LLM) used to generate responses.
+	* @returns A new LLMPlanner instance.
+	*/
+	static async getDefaultPlanner({ llm, tools }) {
+		const plannerLlmChain = new require_llm_chain.LLMChain({
+			llm,
+			prompt: await require_prompt.getPlannerChatPrompt(tools)
+		});
+		return new require_base$1.LLMPlanner(plannerLlmChain, new require_outputParser.PlanOutputParser());
+	}
+	/**
+	* Static method that returns a default step executor for the agent. It
+	* creates a new ChatAgent from a given LLM and a set of tools, and uses
+	* it to create a new ChainStepExecutor.
+	* @param llm The Large Language Model (LLM) used to generate responses.
+	* @param tools The set of tools used by the agent.
+	* @param humanMessageTemplate The template for human messages. If not provided, a default template is used.
+	* @returns A new ChainStepExecutor instance.
+	*/
+	static getDefaultStepExecutor({ llm, tools, humanMessageTemplate = require_prompt.DEFAULT_STEP_EXECUTOR_HUMAN_CHAT_MESSAGE_TEMPLATE }) {
+		let agent;
+		if (tools.length > 0 && isDynamicStructuredTool(tools[0])) {
+			agent = require_index$1.StructuredChatAgent.fromLLMAndTools(llm, tools, {
+				humanMessageTemplate,
+				inputVariables: [
+					"previous_steps",
+					"current_step",
+					"agent_scratchpad"
+				]
+			});
+			return new require_base$1.ChainStepExecutor(require_executor.AgentExecutor.fromAgentAndTools({
+				agent,
+				tools
+			}));
+		}
+		agent = require_index.ChatAgent.fromLLMAndTools(llm, tools, { humanMessageTemplate });
+		return new require_base$1.ChainStepExecutor(require_executor.AgentExecutor.fromAgentAndTools({
+			agent,
+			tools
+		}));
+	}
+	/**
+	* Static method that creates a new PlanAndExecuteAgentExecutor from a
+	* given LLM, a set of tools, and optionally a human message template. It
+	* uses the getDefaultPlanner and getDefaultStepExecutor methods to create
+	* the planner and step executor for the new agent executor.
+	* @param llm The Large Language Model (LLM) used to generate responses.
+	* @param tools The set of tools used by the agent.
+	* @param humanMessageTemplate The template for human messages. If not provided, a default template is used.
+	* @returns A new PlanAndExecuteAgentExecutor instance.
+	*/
+	static async fromLLMAndTools({ llm, tools, humanMessageTemplate }) {
+		const executor = new PlanAndExecuteAgentExecutor({
+			planner: await PlanAndExecuteAgentExecutor.getDefaultPlanner({
+				llm,
+				tools
+			}),
+			stepExecutor: PlanAndExecuteAgentExecutor.getDefaultStepExecutor({
+				llm,
+				tools,
+				humanMessageTemplate
+			})
+		});
+		return executor;
+	}
+	/** @ignore */
+	async _call(inputs, runManager) {
+		const plan = await this.planner.plan(inputs.input, runManager?.getChild());
+		if (!plan.steps?.length) throw new Error("Could not create and parse a plan to answer your question - please try again.");
+		plan.steps[plan.steps.length - 1].text += ` The original question was: ${inputs.input}.`;
+		for (const step of plan.steps) {
+			const newInputs = {
+				...inputs,
+				previous_steps: JSON.stringify(this.stepContainer.getSteps()),
+				current_step: step.text
+			};
+			const response = await this.stepExecutor.step(newInputs, runManager?.getChild());
+			this.stepContainer.addStep(step, response);
+		}
+		return { [this.outputKey]: this.stepContainer.getFinalResponse() };
+	}
+	_chainType() {
+		return "agent_executor";
+	}
+	serialize() {
+		throw new Error("Cannot serialize an AgentExecutor");
+	}
+};
+
+//#endregion
+exports.PlanAndExecuteAgentExecutor = PlanAndExecuteAgentExecutor;
+//# sourceMappingURL=agent_executor.cjs.map

package/dist/experimental/plan_and_execute/agent_executor.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent_executor.cjs","names":["tool: Tool | DynamicStructuredTool","BaseChain","ListStepContainer","input: PlanAndExecuteAgentExecutorInput","LLMChain","getPlannerChatPrompt","LLMPlanner","PlanOutputParser","DEFAULT_STEP_EXECUTOR_HUMAN_CHAT_MESSAGE_TEMPLATE","StructuredChatAgent","ChainStepExecutor","AgentExecutor","ChatAgent","inputs: ChainValues","runManager?: CallbackManagerForChainRun"],"sources":["../../../src/experimental/plan_and_execute/agent_executor.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { Tool, DynamicStructuredTool } from \"@langchain/core/tools\";\nimport { CallbackManagerForChainRun } from \"@langchain/core/callbacks/manager\";\nimport { BaseChain, ChainInputs } from \"../../chains/base.js\";\nimport {\n  BasePlanner,\n  BaseStepContainer,\n  BaseStepExecutor,\n  ListStepContainer,\n  LLMPlanner,\n  ChainStepExecutor,\n} from \"./base.js\";\nimport { AgentExecutor } from \"../../agents/executor.js\";\nimport {\n  DEFAULT_STEP_EXECUTOR_HUMAN_CHAT_MESSAGE_TEMPLATE,\n  getPlannerChatPrompt,\n} from \"./prompt.js\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\nimport { PlanOutputParser } from \"./outputParser.js\";\nimport { ChatAgent } from \"../../agents/chat/index.js\";\nimport { StructuredChatAgent } from \"../../agents/index.js\";\nimport { SerializedLLMChain } from \"../../chains/serde.js\";\n\n/**\n * A utility function to distiguish a dynamicstructuredtool over other tools.\n * @param tool the tool to test\n * @returns bool\n */\nexport function isDynamicStructuredTool(\n  tool: Tool | DynamicStructuredTool\n): tool is DynamicStructuredTool {\n  // We check for the existence of the static lc_name method in the object's constructor\n  return (\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    typeof (tool.constructor as any).lc_name === \"function\" &&\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (tool.constructor as any).lc_name() === \"DynamicStructuredTool\"\n  );\n}\n\n/**\n * Interface for the input to the PlanAndExecuteAgentExecutor class. It\n * extends ChainInputs and includes additional properties for the planner,\n * step executor, step container, and input and output keys.\n */\nexport interface PlanAndExecuteAgentExecutorInput extends ChainInputs {\n  planner: BasePlanner;\n  stepExecutor: BaseStepExecutor;\n  stepContainer?: BaseStepContainer;\n  inputKey?: string;\n  outputKey?: string;\n}\n\n/**\n * Class representing a plan-and-execute agent executor. This agent\n * decides on the full sequence of actions upfront, then executes them all\n * without updating the plan. This is suitable for complex or long-running\n * tasks that require maintaining long-term objectives and focus.\n */\nexport class PlanAndExecuteAgentExecutor extends BaseChain {\n  static lc_name() {\n    return \"PlanAndExecuteAgentExecutor\";\n  }\n\n  private planner: BasePlanner;\n\n  private stepExecutor: BaseStepExecutor;\n\n  private stepContainer: BaseStepContainer = new ListStepContainer();\n\n  private inputKey = \"input\";\n\n  private outputKey = \"output\";\n\n  constructor(input: PlanAndExecuteAgentExecutorInput) {\n    super(input);\n    this.planner = input.planner;\n    this.stepExecutor = input.stepExecutor;\n    this.stepContainer = input.stepContainer ?? this.stepContainer;\n    this.inputKey = input.inputKey ?? this.inputKey;\n    this.outputKey = input.outputKey ?? this.outputKey;\n  }\n\n  get inputKeys() {\n    return [this.inputKey];\n  }\n\n  get outputKeys() {\n    return [this.outputKey];\n  }\n\n  /**\n   * Static method that returns a default planner for the agent. It creates\n   * a new LLMChain with a given LLM and a fixed prompt, and uses it to\n   * create a new LLMPlanner with a PlanOutputParser.\n   * @param llm The Large Language Model (LLM) used to generate responses.\n   * @returns A new LLMPlanner instance.\n   */\n\n  static async getDefaultPlanner({\n    llm,\n    tools,\n  }: {\n    llm: BaseLanguageModelInterface;\n    tools: Tool[] | DynamicStructuredTool[];\n  }) {\n    const plannerLlmChain = new LLMChain({\n      llm,\n      prompt: await getPlannerChatPrompt(tools),\n    });\n    return new LLMPlanner(plannerLlmChain, new PlanOutputParser());\n  }\n\n  /**\n   * Static method that returns a default step executor for the agent. It\n   * creates a new ChatAgent from a given LLM and a set of tools, and uses\n   * it to create a new ChainStepExecutor.\n   * @param llm The Large Language Model (LLM) used to generate responses.\n   * @param tools The set of tools used by the agent.\n   * @param humanMessageTemplate The template for human messages. If not provided, a default template is used.\n   * @returns A new ChainStepExecutor instance.\n   */\n  static getDefaultStepExecutor({\n    llm,\n    tools,\n    humanMessageTemplate = DEFAULT_STEP_EXECUTOR_HUMAN_CHAT_MESSAGE_TEMPLATE,\n  }: {\n    llm: BaseLanguageModelInterface;\n    tools: Tool[] | DynamicStructuredTool[];\n    humanMessageTemplate?: string;\n  }) {\n    let agent;\n\n    if (tools.length > 0 && isDynamicStructuredTool(tools[0])) {\n      agent = StructuredChatAgent.fromLLMAndTools(llm, tools, {\n        humanMessageTemplate,\n        inputVariables: [\"previous_steps\", \"current_step\", \"agent_scratchpad\"],\n      });\n      return new ChainStepExecutor(\n        AgentExecutor.fromAgentAndTools({\n          agent,\n          tools,\n        })\n      );\n    }\n\n    agent = ChatAgent.fromLLMAndTools(llm, tools as Tool[], {\n      humanMessageTemplate,\n    });\n    return new ChainStepExecutor(\n      AgentExecutor.fromAgentAndTools({\n        agent,\n        tools,\n      })\n    );\n  }\n\n  /**\n   * Static method that creates a new PlanAndExecuteAgentExecutor from a\n   * given LLM, a set of tools, and optionally a human message template. It\n   * uses the getDefaultPlanner and getDefaultStepExecutor methods to create\n   * the planner and step executor for the new agent executor.\n   * @param llm The Large Language Model (LLM) used to generate responses.\n   * @param tools The set of tools used by the agent.\n   * @param humanMessageTemplate The template for human messages. If not provided, a default template is used.\n   * @returns A new PlanAndExecuteAgentExecutor instance.\n   */\n  static async fromLLMAndTools({\n    llm,\n    tools,\n    humanMessageTemplate,\n  }: {\n    llm: BaseLanguageModelInterface;\n    tools: Tool[] | DynamicStructuredTool[];\n    humanMessageTemplate?: string;\n  } & Omit<PlanAndExecuteAgentExecutorInput, \"planner\" | \"stepExecutor\">) {\n    const executor = new PlanAndExecuteAgentExecutor({\n      planner: await PlanAndExecuteAgentExecutor.getDefaultPlanner({\n        llm,\n        tools,\n      }),\n      stepExecutor: PlanAndExecuteAgentExecutor.getDefaultStepExecutor({\n        llm,\n        tools,\n        humanMessageTemplate,\n      }),\n    });\n    return executor;\n  }\n\n  /** @ignore */\n  async _call(\n    inputs: ChainValues,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<ChainValues> {\n    const plan = await this.planner.plan(inputs.input, runManager?.getChild());\n    if (!plan.steps?.length) {\n      throw new Error(\n        \"Could not create and parse a plan to answer your question - please try again.\"\n      );\n    }\n    plan.steps[\n      plan.steps.length - 1\n    ].text += ` The original question was: ${inputs.input}.`;\n    for (const step of plan.steps) {\n      const newInputs = {\n        ...inputs,\n        previous_steps: JSON.stringify(this.stepContainer.getSteps()),\n        current_step: step.text,\n      };\n      const response = await this.stepExecutor.step(\n        newInputs,\n        runManager?.getChild()\n      );\n      this.stepContainer.addStep(step, response);\n    }\n    return { [this.outputKey]: this.stepContainer.getFinalResponse() };\n  }\n\n  _chainType() {\n    return \"agent_executor\" as const;\n  }\n\n  serialize(): SerializedLLMChain {\n    throw new Error(\"Cannot serialize an AgentExecutor\");\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA6BA,SAAgB,wBACdA,MAC+B;AAE/B,QAEE,OAAQ,KAAK,YAAoB,YAAY,cAE5C,KAAK,YAAoB,SAAS,KAAK;AAE3C;;;;;;;AAqBD,IAAa,8BAAb,MAAa,oCAAoCC,uBAAU;CACzD,OAAO,UAAU;AACf,SAAO;CACR;CAED,AAAQ;CAER,AAAQ;CAER,AAAQ,gBAAmC,IAAIC;CAE/C,AAAQ,WAAW;CAEnB,AAAQ,YAAY;CAEpB,YAAYC,OAAyC;EACnD,MAAM,MAAM;EACZ,KAAK,UAAU,MAAM;EACrB,KAAK,eAAe,MAAM;EAC1B,KAAK,gBAAgB,MAAM,iBAAiB,KAAK;EACjD,KAAK,WAAW,MAAM,YAAY,KAAK;EACvC,KAAK,YAAY,MAAM,aAAa,KAAK;CAC1C;CAED,IAAI,YAAY;AACd,SAAO,CAAC,KAAK,QAAS;CACvB;CAED,IAAI,aAAa;AACf,SAAO,CAAC,KAAK,SAAU;CACxB;;;;;;;;CAUD,aAAa,kBAAkB,EAC7B,KACA,OAID,EAAE;EACD,MAAM,kBAAkB,IAAIC,2BAAS;GACnC;GACA,QAAQ,MAAMC,oCAAqB,MAAM;EAC1C;AACD,SAAO,IAAIC,0BAAW,iBAAiB,IAAIC;CAC5C;;;;;;;;;;CAWD,OAAO,uBAAuB,EAC5B,KACA,OACA,uBAAuBC,kEAKxB,EAAE;EACD,IAAI;AAEJ,MAAI,MAAM,SAAS,KAAK,wBAAwB,MAAM,GAAG,EAAE;GACzD,QAAQC,oCAAoB,gBAAgB,KAAK,OAAO;IACtD;IACA,gBAAgB;KAAC;KAAkB;KAAgB;IAAmB;GACvE,EAAC;AACF,UAAO,IAAIC,iCACTC,+BAAc,kBAAkB;IAC9B;IACA;GACD,EAAC;EAEL;EAED,QAAQC,wBAAU,gBAAgB,KAAK,OAAiB,EACtD,qBACD,EAAC;AACF,SAAO,IAAIF,iCACTC,+BAAc,kBAAkB;GAC9B;GACA;EACD,EAAC;CAEL;;;;;;;;;;;CAYD,aAAa,gBAAgB,EAC3B,KACA,OACA,sBAKoE,EAAE;EACtE,MAAM,WAAW,IAAI,4BAA4B;GAC/C,SAAS,MAAM,4BAA4B,kBAAkB;IAC3D;IACA;GACD,EAAC;GACF,cAAc,4BAA4B,uBAAuB;IAC/D;IACA;IACA;GACD,EAAC;EACH;AACD,SAAO;CACR;;CAGD,MAAM,MACJE,QACAC,YACsB;EACtB,MAAM,OAAO,MAAM,KAAK,QAAQ,KAAK,OAAO,OAAO,YAAY,UAAU,CAAC;AAC1E,MAAI,CAAC,KAAK,OAAO,OACf,OAAM,IAAI,MACR;EAGJ,KAAK,MACH,KAAK,MAAM,SAAS,GACpB,QAAQ,CAAC,4BAA4B,EAAE,OAAO,MAAM,CAAC,CAAC;AACxD,OAAK,MAAM,QAAQ,KAAK,OAAO;GAC7B,MAAM,YAAY;IAChB,GAAG;IACH,gBAAgB,KAAK,UAAU,KAAK,cAAc,UAAU,CAAC;IAC7D,cAAc,KAAK;GACpB;GACD,MAAM,WAAW,MAAM,KAAK,aAAa,KACvC,WACA,YAAY,UAAU,CACvB;GACD,KAAK,cAAc,QAAQ,MAAM,SAAS;EAC3C;AACD,SAAO,GAAG,KAAK,YAAY,KAAK,cAAc,kBAAkB,CAAE;CACnE;CAED,aAAa;AACX,SAAO;CACR;CAED,YAAgC;AAC9B,QAAM,IAAI,MAAM;CACjB;AACF"}

package/dist/experimental/plan_and_execute/agent_executor.d.cts

@@ -0,0 +1,97 @@
+import { SerializedLLMChain } from "../../chains/serde.cjs";
+import { BaseChain, ChainInputs } from "../../chains/base.cjs";
+import { BasePlanner, BaseStepContainer, BaseStepExecutor, ChainStepExecutor, LLMPlanner } from "./base.cjs";
+import { ChainValues } from "@langchain/core/utils/types";
+import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
+import { DynamicStructuredTool, Tool } from "@langchain/core/tools";
+
+//#region src/experimental/plan_and_execute/agent_executor.d.ts
+
+/**
+ * Interface for the input to the PlanAndExecuteAgentExecutor class. It
+ * extends ChainInputs and includes additional properties for the planner,
+ * step executor, step container, and input and output keys.
+ */
+interface PlanAndExecuteAgentExecutorInput extends ChainInputs {
+  planner: BasePlanner;
+  stepExecutor: BaseStepExecutor;
+  stepContainer?: BaseStepContainer;
+  inputKey?: string;
+  outputKey?: string;
+}
+/**
+ * Class representing a plan-and-execute agent executor. This agent
+ * decides on the full sequence of actions upfront, then executes them all
+ * without updating the plan. This is suitable for complex or long-running
+ * tasks that require maintaining long-term objectives and focus.
+ */
+declare class PlanAndExecuteAgentExecutor extends BaseChain {
+  static lc_name(): string;
+  private planner;
+  private stepExecutor;
+  private stepContainer;
+  private inputKey;
+  private outputKey;
+  constructor(input: PlanAndExecuteAgentExecutorInput);
+  get inputKeys(): string[];
+  get outputKeys(): string[];
+  /**
+   * Static method that returns a default planner for the agent. It creates
+   * a new LLMChain with a given LLM and a fixed prompt, and uses it to
+   * create a new LLMPlanner with a PlanOutputParser.
+   * @param llm The Large Language Model (LLM) used to generate responses.
+   * @returns A new LLMPlanner instance.
+   */
+  static getDefaultPlanner({
+    llm,
+    tools
+  }: {
+    llm: BaseLanguageModelInterface;
+    tools: Tool[] | DynamicStructuredTool[];
+  }): Promise<LLMPlanner>;
+  /**
+   * Static method that returns a default step executor for the agent. It
+   * creates a new ChatAgent from a given LLM and a set of tools, and uses
+   * it to create a new ChainStepExecutor.
+   * @param llm The Large Language Model (LLM) used to generate responses.
+   * @param tools The set of tools used by the agent.
+   * @param humanMessageTemplate The template for human messages. If not provided, a default template is used.
+   * @returns A new ChainStepExecutor instance.
+   */
+  static getDefaultStepExecutor({
+    llm,
+    tools,
+    humanMessageTemplate
+  }: {
+    llm: BaseLanguageModelInterface;
+    tools: Tool[] | DynamicStructuredTool[];
+    humanMessageTemplate?: string;
+  }): ChainStepExecutor;
+  /**
+   * Static method that creates a new PlanAndExecuteAgentExecutor from a
+   * given LLM, a set of tools, and optionally a human message template. It
+   * uses the getDefaultPlanner and getDefaultStepExecutor methods to create
+   * the planner and step executor for the new agent executor.
+   * @param llm The Large Language Model (LLM) used to generate responses.
+   * @param tools The set of tools used by the agent.
+   * @param humanMessageTemplate The template for human messages. If not provided, a default template is used.
+   * @returns A new PlanAndExecuteAgentExecutor instance.
+   */
+  static fromLLMAndTools({
+    llm,
+    tools,
+    humanMessageTemplate
+  }: {
+    llm: BaseLanguageModelInterface;
+    tools: Tool[] | DynamicStructuredTool[];
+    humanMessageTemplate?: string;
+  } & Omit<PlanAndExecuteAgentExecutorInput, "planner" | "stepExecutor">): Promise<PlanAndExecuteAgentExecutor>;
+  /** @ignore */
+  _call(inputs: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;
+  _chainType(): "agent_executor";
+  serialize(): SerializedLLMChain;
+}
+//#endregion
+export { PlanAndExecuteAgentExecutor };
+//# sourceMappingURL=agent_executor.d.cts.map

package/dist/experimental/plan_and_execute/agent_executor.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent_executor.d.cts","names":["BaseLanguageModelInterface","ChainValues","Tool","DynamicStructuredTool","CallbackManagerForChainRun","BaseChain","ChainInputs","BasePlanner","BaseStepContainer","BaseStepExecutor","LLMPlanner","ChainStepExecutor","SerializedLLMChain","isDynamicStructuredTool","PlanAndExecuteAgentExecutorInput","PlanAndExecuteAgentExecutor","llm","tools","Promise","humanMessageTemplate","Omit"],"sources":["../../../src/experimental/plan_and_execute/agent_executor.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { Tool, DynamicStructuredTool } from \"@langchain/core/tools\";\nimport { CallbackManagerForChainRun } from \"@langchain/core/callbacks/manager\";\nimport { BaseChain, ChainInputs } from \"../../chains/base.js\";\nimport { BasePlanner, BaseStepContainer, BaseStepExecutor, LLMPlanner, ChainStepExecutor } from \"./base.js\";\nimport { SerializedLLMChain } from \"../../chains/serde.js\";\n/**\n * A utility function to distiguish a dynamicstructuredtool over other tools.\n * @param tool the tool to test\n * @returns bool\n */\nexport declare function isDynamicStructuredTool(tool: Tool | DynamicStructuredTool): tool is DynamicStructuredTool;\n/**\n * Interface for the input to the PlanAndExecuteAgentExecutor class. It\n * extends ChainInputs and includes additional properties for the planner,\n * step executor, step container, and input and output keys.\n */\nexport interface PlanAndExecuteAgentExecutorInput extends ChainInputs {\n    planner: BasePlanner;\n    stepExecutor: BaseStepExecutor;\n    stepContainer?: BaseStepContainer;\n    inputKey?: string;\n    outputKey?: string;\n}\n/**\n * Class representing a plan-and-execute agent executor. This agent\n * decides on the full sequence of actions upfront, then executes them all\n * without updating the plan. This is suitable for complex or long-running\n * tasks that require maintaining long-term objectives and focus.\n */\nexport declare class PlanAndExecuteAgentExecutor extends BaseChain {\n    static lc_name(): string;\n    private planner;\n    private stepExecutor;\n    private stepContainer;\n    private inputKey;\n    private outputKey;\n    constructor(input: PlanAndExecuteAgentExecutorInput);\n    get inputKeys(): string[];\n    get outputKeys(): string[];\n    /**\n     * Static method that returns a default planner for the agent. It creates\n     * a new LLMChain with a given LLM and a fixed prompt, and uses it to\n     * create a new LLMPlanner with a PlanOutputParser.\n     * @param llm The Large Language Model (LLM) used to generate responses.\n     * @returns A new LLMPlanner instance.\n     */\n    static getDefaultPlanner({ llm, tools }: {\n        llm: BaseLanguageModelInterface;\n        tools: Tool[] | DynamicStructuredTool[];\n    }): Promise<LLMPlanner>;\n    /**\n     * Static method that returns a default step executor for the agent. It\n     * creates a new ChatAgent from a given LLM and a set of tools, and uses\n     * it to create a new ChainStepExecutor.\n     * @param llm The Large Language Model (LLM) used to generate responses.\n     * @param tools The set of tools used by the agent.\n     * @param humanMessageTemplate The template for human messages. If not provided, a default template is used.\n     * @returns A new ChainStepExecutor instance.\n     */\n    static getDefaultStepExecutor({ llm, tools, humanMessageTemplate }: {\n        llm: BaseLanguageModelInterface;\n        tools: Tool[] | DynamicStructuredTool[];\n        humanMessageTemplate?: string;\n    }): ChainStepExecutor;\n    /**\n     * Static method that creates a new PlanAndExecuteAgentExecutor from a\n     * given LLM, a set of tools, and optionally a human message template. It\n     * uses the getDefaultPlanner and getDefaultStepExecutor methods to create\n     * the planner and step executor for the new agent executor.\n     * @param llm The Large Language Model (LLM) used to generate responses.\n     * @param tools The set of tools used by the agent.\n     * @param humanMessageTemplate The template for human messages. If not provided, a default template is used.\n     * @returns A new PlanAndExecuteAgentExecutor instance.\n     */\n    static fromLLMAndTools({ llm, tools, humanMessageTemplate }: {\n        llm: BaseLanguageModelInterface;\n        tools: Tool[] | DynamicStructuredTool[];\n        humanMessageTemplate?: string;\n    } & Omit<PlanAndExecuteAgentExecutorInput, \"planner\" | \"stepExecutor\">): Promise<PlanAndExecuteAgentExecutor>;\n    /** @ignore */\n    _call(inputs: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;\n    _chainType(): \"agent_executor\";\n    serialize(): SerializedLLMChain;\n}\n"],"mappings":";;;;;;;;;;;;AAkBqE;AAarE;;AAOuBc,UApBNA,gCAAAA,SAAyCR,WAoBnCQ,CAAAA;EAAgC,OAUxBE,EA7BlBT,WA6BkBS;EAAG,YAAEC,EA5BlBR,gBA4BkBQ;EAAK,aAC5BjB,CAAAA,EA5BOQ,iBA4BPR;EAA0B,QACxBE,CAAAA,EAAAA,MAAAA;EAAI,SAAKC,CAAAA,EAAAA,MAAAA;;;;;;;;AAaAA,cAhCHY,2BAAAA,SAAoCV,SAAAA,CAgCjCF;EAAqB,OAErCQ,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAiB,QAWIK,OAAAA;EAAG,QAAEC,YAAAA;EAAK,QAAEE,aAAAA;EAAoB,QAChDnB,QAAAA;EAA0B,QACxBE,SAAAA;EAAI,WAAKC,CAAAA,KAAAA,EAxCDW,gCAwCCX;EAAqB,IAEhCW,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAgC,IAArCM,UAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAI;;;;;;;EAIuB,OArDsBf,iBAAAA,CAAAA;IAAAA,GAAAA;IAAAA;GAAAA,EAAAA;IAAS,GAAA,EAkBrDL,0BAlBqD;WAmBnDE,SAASC;MAChBe,QAAQR;;;;;;;;;;;;;;;SAWHV;WACEE,SAASC;;MAEhBQ;;;;;;;;;;;;;;;;SAYKX;WACEE,SAASC;;MAEhBiB,KAAKN,gEAAgEI,QAAQH;;gBAEnEd,0BAA0BG,6BAA6Bc,QAAQjB;;eAEhEW"}