langchain 0.0.63 → 0.0.65

package/dist/experimental/babyagi/agent.cjs

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BabyAGI = void 0;
+const base_js_1 = require("../../chains/base.cjs");
+const document_js_1 = require("../../document.cjs");
+const task_creation_js_1 = require("./task_creation.cjs");
+const task_execution_js_1 = require("./task_execution.cjs");
+const task_prioritization_js_1 = require("./task_prioritization.cjs");
+class BabyAGI extends base_js_1.BaseChain {
+    constructor({ creationChain, prioritizationChain, executionChain, vectorstore, maxIterations = 100, verbose, callbacks, }) {
+        super(undefined, verbose, callbacks);
+        Object.defineProperty(this, "taskList", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "creationChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "prioritizationChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "executionChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "taskIDCounter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "vectorstore", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maxIterations", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.taskList = [];
+        this.creationChain = creationChain;
+        this.prioritizationChain = prioritizationChain;
+        this.executionChain = executionChain;
+        this.taskIDCounter = 1;
+        this.vectorstore = vectorstore;
+        this.maxIterations = maxIterations;
+    }
+    _chainType() {
+        return "BabyAGI";
+    }
+    get inputKeys() {
+        return ["objective", "firstTask"];
+    }
+    get outputKeys() {
+        return [];
+    }
+    async addTask(task) {
+        this.taskList.push(task);
+    }
+    printTaskList() {
+        console.log("\x1b[95m\x1b[1m\n*****TASK LIST*****\n\x1b[0m\x1b[0m");
+        for (const t of this.taskList) {
+            console.log(`${t.taskID}: ${t.taskName}`);
+        }
+    }
+    printNextTask(task) {
+        console.log("\x1b[92m\x1b[1m\n*****NEXT TASK*****\n\x1b[0m\x1b[0m");
+        console.log(`${task.taskID}: ${task.taskName}`);
+    }
+    printTaskResult(result) {
+        console.log("\x1b[93m\x1b[1m\n*****TASK RESULT*****\n\x1b[0m\x1b[0m");
+        console.log(result.trim());
+    }
+    async getNextTasks(result, task_description, objective, runManager) {
+        const taskNames = this.taskList.map((t) => t.taskName);
+        const incomplete_tasks = taskNames.join(", ");
+        const { [this.creationChain.outputKeys[0]]: text } = await this.creationChain.call({
+            result,
+            task_description,
+            incomplete_tasks,
+            objective,
+        }, runManager?.getChild());
+        const newTasks = text.split("\n");
+        return newTasks
+            .filter((taskName) => taskName.trim())
+            .map((taskName) => ({ taskName }));
+    }
+    async prioritizeTasks(thisTaskID, objective, runManager) {
+        const taskNames = this.taskList.map((t) => t.taskName);
+        const nextTaskID = thisTaskID + 1;
+        const { [this.prioritizationChain.outputKeys[0]]: text } = await this.prioritizationChain.call({
+            task_names: taskNames.join(", "),
+            next_task_id: String(nextTaskID),
+            objective,
+        }, runManager?.getChild());
+        const newTasks = text.trim().split("\n");
+        const prioritizedTaskList = [];
+        for (const taskString of newTasks) {
+            const taskParts = taskString.trim().split(".", 2);
+            if (taskParts.length === 2) {
+                const taskID = taskParts[0].trim();
+                const taskName = taskParts[1].trim();
+                prioritizedTaskList.push({ taskID, taskName });
+            }
+        }
+        return prioritizedTaskList;
+    }
+    async getTopTasks(query, k = 5) {
+        const results = await this.vectorstore.similaritySearch(query, k);
+        if (!results) {
+            return [];
+        }
+        return results.map((item) => String(item.metadata.task));
+    }
+    async executeTask(objective, task, runManager) {
+        const context = await this.getTopTasks(objective);
+        const { [this.executionChain.outputKeys[0]]: text } = await this.executionChain.call({
+            objective,
+            context: context.join("\n"),
+            task,
+        }, runManager?.getChild());
+        return text;
+    }
+    async _call({ objective, firstTask = "Make a todo list" }, runManager) {
+        this.taskList = [];
+        this.taskIDCounter = 1;
+        await this.addTask({ taskID: "1", taskName: firstTask });
+        let numIters = 0;
+        while (numIters < this.maxIterations && this.taskList.length > 0) {
+            this.printTaskList();
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const task = this.taskList.shift();
+            this.printNextTask(task);
+            const result = await this.executeTask(objective, task.taskName, runManager);
+            const thisTaskID = parseInt(task.taskID, 10);
+            this.printTaskResult(result);
+            await this.vectorstore.addDocuments([
+                new document_js_1.Document({
+                    pageContent: result,
+                    metadata: { task: task.taskName },
+                }),
+            ]);
+            const newTasks = await this.getNextTasks(result, task.taskName, objective, runManager);
+            for (const newTask of newTasks) {
+                this.taskIDCounter += 1;
+                newTask.taskID = this.taskIDCounter.toFixed();
+                await this.addTask(newTask);
+            }
+            this.taskList = await this.prioritizeTasks(thisTaskID, objective, runManager);
+            numIters += 1;
+        }
+        return {};
+    }
+    serialize() {
+        throw new Error("Method not implemented.");
+    }
+    static fromLLM({ llm, vectorstore, executionChain, verbose, callbacks, ...rest }) {
+        const creationChain = task_creation_js_1.TaskCreationChain.fromLLM({
+            llm,
+            verbose,
+            callbacks,
+        });
+        const prioritizationChain = task_prioritization_js_1.TaskPrioritizationChain.fromLLM({
+            llm,
+            verbose,
+            callbacks,
+        });
+        return new BabyAGI({
+            creationChain,
+            prioritizationChain,
+            executionChain: executionChain ||
+                task_execution_js_1.TaskExecutionChain.fromLLM({ llm, verbose, callbacks }),
+            vectorstore,
+            verbose,
+            callbacks,
+            ...rest,
+        });
+    }
+}
+exports.BabyAGI = BabyAGI;

package/dist/experimental/babyagi/agent.d.ts

@@ -0,0 +1,47 @@
+import { BaseLanguageModel } from "../../base_language/index.js";
+import { CallbackManagerForChainRun } from "../../callbacks/manager.js";
+import { BaseChain, ChainInputs } from "../../chains/base.js";
+import { SerializedBaseChain } from "../../chains/serde.js";
+import { ChainValues } from "../../schema/index.js";
+import { Optional } from "../../types/type-utils.js";
+import { VectorStore } from "../../vectorstores/base.js";
+export interface Task {
+    taskID: string;
+    taskName: string;
+}
+export interface BabyAGIInputs extends Omit<ChainInputs, "memory" | "callbackManager"> {
+    creationChain: BaseChain;
+    prioritizationChain: BaseChain;
+    executionChain: BaseChain;
+    vectorstore: VectorStore;
+    maxIterations?: number;
+}
+export declare class BabyAGI extends BaseChain implements BabyAGIInputs {
+    taskList: Task[];
+    creationChain: BaseChain;
+    prioritizationChain: BaseChain;
+    executionChain: BaseChain;
+    taskIDCounter: number;
+    vectorstore: VectorStore;
+    maxIterations: number;
+    constructor({ creationChain, prioritizationChain, executionChain, vectorstore, maxIterations, verbose, callbacks, }: BabyAGIInputs);
+    _chainType(): "BabyAGI";
+    get inputKeys(): string[];
+    get outputKeys(): never[];
+    addTask(task: Task): Promise<void>;
+    printTaskList(): void;
+    printNextTask(task: Task): void;
+    printTaskResult(result: string): void;
+    getNextTasks(result: string, task_description: string, objective: string, runManager?: CallbackManagerForChainRun): Promise<Optional<Task, "taskID">[]>;
+    prioritizeTasks(thisTaskID: number, objective: string, runManager?: CallbackManagerForChainRun): Promise<{
+        taskID: string;
+        taskName: string;
+    }[]>;
+    getTopTasks(query: string, k?: number): Promise<string[]>;
+    executeTask(objective: string, task: string, runManager?: CallbackManagerForChainRun): Promise<string>;
+    _call({ objective, firstTask }: ChainValues, runManager?: CallbackManagerForChainRun): Promise<{}>;
+    serialize(): SerializedBaseChain;
+    static fromLLM({ llm, vectorstore, executionChain, verbose, callbacks, ...rest }: Optional<BabyAGIInputs, "executionChain" | "creationChain" | "prioritizationChain"> & {
+        llm: BaseLanguageModel;
+    }): BabyAGI;
+}

package/dist/experimental/babyagi/agent.js

@@ -0,0 +1,190 @@
+import { BaseChain } from "../../chains/base.js";
+import { Document } from "../../document.js";
+import { TaskCreationChain } from "./task_creation.js";
+import { TaskExecutionChain } from "./task_execution.js";
+import { TaskPrioritizationChain } from "./task_prioritization.js";
+export class BabyAGI extends BaseChain {
+    constructor({ creationChain, prioritizationChain, executionChain, vectorstore, maxIterations = 100, verbose, callbacks, }) {
+        super(undefined, verbose, callbacks);
+        Object.defineProperty(this, "taskList", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "creationChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "prioritizationChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "executionChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "taskIDCounter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "vectorstore", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maxIterations", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.taskList = [];
+        this.creationChain = creationChain;
+        this.prioritizationChain = prioritizationChain;
+        this.executionChain = executionChain;
+        this.taskIDCounter = 1;
+        this.vectorstore = vectorstore;
+        this.maxIterations = maxIterations;
+    }
+    _chainType() {
+        return "BabyAGI";
+    }
+    get inputKeys() {
+        return ["objective", "firstTask"];
+    }
+    get outputKeys() {
+        return [];
+    }
+    async addTask(task) {
+        this.taskList.push(task);
+    }
+    printTaskList() {
+        console.log("\x1b[95m\x1b[1m\n*****TASK LIST*****\n\x1b[0m\x1b[0m");
+        for (const t of this.taskList) {
+            console.log(`${t.taskID}: ${t.taskName}`);
+        }
+    }
+    printNextTask(task) {
+        console.log("\x1b[92m\x1b[1m\n*****NEXT TASK*****\n\x1b[0m\x1b[0m");
+        console.log(`${task.taskID}: ${task.taskName}`);
+    }
+    printTaskResult(result) {
+        console.log("\x1b[93m\x1b[1m\n*****TASK RESULT*****\n\x1b[0m\x1b[0m");
+        console.log(result.trim());
+    }
+    async getNextTasks(result, task_description, objective, runManager) {
+        const taskNames = this.taskList.map((t) => t.taskName);
+        const incomplete_tasks = taskNames.join(", ");
+        const { [this.creationChain.outputKeys[0]]: text } = await this.creationChain.call({
+            result,
+            task_description,
+            incomplete_tasks,
+            objective,
+        }, runManager?.getChild());
+        const newTasks = text.split("\n");
+        return newTasks
+            .filter((taskName) => taskName.trim())
+            .map((taskName) => ({ taskName }));
+    }
+    async prioritizeTasks(thisTaskID, objective, runManager) {
+        const taskNames = this.taskList.map((t) => t.taskName);
+        const nextTaskID = thisTaskID + 1;
+        const { [this.prioritizationChain.outputKeys[0]]: text } = await this.prioritizationChain.call({
+            task_names: taskNames.join(", "),
+            next_task_id: String(nextTaskID),
+            objective,
+        }, runManager?.getChild());
+        const newTasks = text.trim().split("\n");
+        const prioritizedTaskList = [];
+        for (const taskString of newTasks) {
+            const taskParts = taskString.trim().split(".", 2);
+            if (taskParts.length === 2) {
+                const taskID = taskParts[0].trim();
+                const taskName = taskParts[1].trim();
+                prioritizedTaskList.push({ taskID, taskName });
+            }
+        }
+        return prioritizedTaskList;
+    }
+    async getTopTasks(query, k = 5) {
+        const results = await this.vectorstore.similaritySearch(query, k);
+        if (!results) {
+            return [];
+        }
+        return results.map((item) => String(item.metadata.task));
+    }
+    async executeTask(objective, task, runManager) {
+        const context = await this.getTopTasks(objective);
+        const { [this.executionChain.outputKeys[0]]: text } = await this.executionChain.call({
+            objective,
+            context: context.join("\n"),
+            task,
+        }, runManager?.getChild());
+        return text;
+    }
+    async _call({ objective, firstTask = "Make a todo list" }, runManager) {
+        this.taskList = [];
+        this.taskIDCounter = 1;
+        await this.addTask({ taskID: "1", taskName: firstTask });
+        let numIters = 0;
+        while (numIters < this.maxIterations && this.taskList.length > 0) {
+            this.printTaskList();
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const task = this.taskList.shift();
+            this.printNextTask(task);
+            const result = await this.executeTask(objective, task.taskName, runManager);
+            const thisTaskID = parseInt(task.taskID, 10);
+            this.printTaskResult(result);
+            await this.vectorstore.addDocuments([
+                new Document({
+                    pageContent: result,
+                    metadata: { task: task.taskName },
+                }),
+            ]);
+            const newTasks = await this.getNextTasks(result, task.taskName, objective, runManager);
+            for (const newTask of newTasks) {
+                this.taskIDCounter += 1;
+                newTask.taskID = this.taskIDCounter.toFixed();
+                await this.addTask(newTask);
+            }
+            this.taskList = await this.prioritizeTasks(thisTaskID, objective, runManager);
+            numIters += 1;
+        }
+        return {};
+    }
+    serialize() {
+        throw new Error("Method not implemented.");
+    }
+    static fromLLM({ llm, vectorstore, executionChain, verbose, callbacks, ...rest }) {
+        const creationChain = TaskCreationChain.fromLLM({
+            llm,
+            verbose,
+            callbacks,
+        });
+        const prioritizationChain = TaskPrioritizationChain.fromLLM({
+            llm,
+            verbose,
+            callbacks,
+        });
+        return new BabyAGI({
+            creationChain,
+            prioritizationChain,
+            executionChain: executionChain ||
+                TaskExecutionChain.fromLLM({ llm, verbose, callbacks }),
+            vectorstore,
+            verbose,
+            callbacks,
+            ...rest,
+        });
+    }
+}

package/dist/experimental/babyagi/index.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BabyAGI = exports.TaskPrioritizationChain = exports.TaskExecutionChain = exports.TaskCreationChain = void 0;
+var task_creation_js_1 = require("./task_creation.cjs");
+Object.defineProperty(exports, "TaskCreationChain", { enumerable: true, get: function () { return task_creation_js_1.TaskCreationChain; } });
+var task_execution_js_1 = require("./task_execution.cjs");
+Object.defineProperty(exports, "TaskExecutionChain", { enumerable: true, get: function () { return task_execution_js_1.TaskExecutionChain; } });
+var task_prioritization_js_1 = require("./task_prioritization.cjs");
+Object.defineProperty(exports, "TaskPrioritizationChain", { enumerable: true, get: function () { return task_prioritization_js_1.TaskPrioritizationChain; } });
+var agent_js_1 = require("./agent.cjs");
+Object.defineProperty(exports, "BabyAGI", { enumerable: true, get: function () { return agent_js_1.BabyAGI; } });

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

@@ -0,0 +1,4 @@
+export { TaskCreationChain } from "./task_creation.js";
+export { TaskExecutionChain } from "./task_execution.js";
+export { TaskPrioritizationChain } from "./task_prioritization.js";
+export { BabyAGI, Task, BabyAGIInputs } from "./agent.js";

package/dist/experimental/babyagi/index.js

@@ -0,0 +1,4 @@
+export { TaskCreationChain } from "./task_creation.js";
+export { TaskExecutionChain } from "./task_execution.js";
+export { TaskPrioritizationChain } from "./task_prioritization.js";
+export { BabyAGI } from "./agent.js";

package/dist/experimental/babyagi/task_creation.cjs

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskCreationChain = void 0;
+const llm_chain_js_1 = require("../../chains/llm_chain.cjs");
+const prompt_js_1 = require("../../prompts/prompt.cjs");
+/** Chain to generate tasks. */
+class TaskCreationChain extends llm_chain_js_1.LLMChain {
+    static fromLLM(fields) {
+        const taskCreationTemplate = `You are an task creation AI that uses the result of an execution agent` +
+            ` to create new tasks with the following objective: {objective},` +
+            ` The last completed task has the result: {result}.` +
+            ` This result was based on this task description: {task_description}.` +
+            ` These are incomplete tasks: {incomplete_tasks}.` +
+            ` Based on the result, create new tasks to be completed` +
+            ` by the AI system that do not overlap with incomplete tasks.` +
+            ` Return the tasks as an array.`;
+        const prompt = new prompt_js_1.PromptTemplate({
+            template: taskCreationTemplate,
+            inputVariables: [
+                "result",
+                "task_description",
+                "incomplete_tasks",
+                "objective",
+            ],
+        });
+        return new TaskCreationChain({ prompt, ...fields });
+    }
+}
+exports.TaskCreationChain = TaskCreationChain;

package/dist/experimental/babyagi/task_creation.d.ts

@@ -0,0 +1,5 @@
+import { LLMChain, LLMChainInput } from "../../chains/llm_chain.js";
+/** Chain to generate tasks. */
+export declare class TaskCreationChain extends LLMChain {
+    static fromLLM(fields: Omit<LLMChainInput, "prompt">): LLMChain;
+}

package/dist/experimental/babyagi/task_creation.js

@@ -0,0 +1,25 @@
+import { LLMChain } from "../../chains/llm_chain.js";
+import { PromptTemplate } from "../../prompts/prompt.js";
+/** Chain to generate tasks. */
+export class TaskCreationChain extends LLMChain {
+    static fromLLM(fields) {
+        const taskCreationTemplate = `You are an task creation AI that uses the result of an execution agent` +
+            ` to create new tasks with the following objective: {objective},` +
+            ` The last completed task has the result: {result}.` +
+            ` This result was based on this task description: {task_description}.` +
+            ` These are incomplete tasks: {incomplete_tasks}.` +
+            ` Based on the result, create new tasks to be completed` +
+            ` by the AI system that do not overlap with incomplete tasks.` +
+            ` Return the tasks as an array.`;
+        const prompt = new PromptTemplate({
+            template: taskCreationTemplate,
+            inputVariables: [
+                "result",
+                "task_description",
+                "incomplete_tasks",
+                "objective",
+            ],
+        });
+        return new TaskCreationChain({ prompt, ...fields });
+    }
+}

package/dist/experimental/babyagi/task_execution.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskExecutionChain = void 0;
+const llm_chain_js_1 = require("../../chains/llm_chain.cjs");
+const prompt_js_1 = require("../../prompts/prompt.cjs");
+/** Chain to execute tasks. */
+class TaskExecutionChain extends llm_chain_js_1.LLMChain {
+    static fromLLM(fields) {
+        const executionTemplate = `You are an AI who performs one task based on the following objective: ` +
+            `{objective}.` +
+            `Take into account these previously completed tasks: {context}.` +
+            ` Your task: {task}. Response:`;
+        const prompt = new prompt_js_1.PromptTemplate({
+            template: executionTemplate,
+            inputVariables: ["objective", "context", "task"],
+        });
+        return new TaskExecutionChain({ prompt, ...fields });
+    }
+}
+exports.TaskExecutionChain = TaskExecutionChain;

package/dist/experimental/babyagi/task_execution.d.ts

@@ -0,0 +1,5 @@
+import { LLMChain, LLMChainInput } from "../../chains/llm_chain.js";
+/** Chain to execute tasks. */
+export declare class TaskExecutionChain extends LLMChain {
+    static fromLLM(fields: Omit<LLMChainInput, "prompt">): LLMChain;
+}

package/dist/experimental/babyagi/task_execution.js

@@ -0,0 +1,16 @@
+import { LLMChain } from "../../chains/llm_chain.js";
+import { PromptTemplate } from "../../prompts/prompt.js";
+/** Chain to execute tasks. */
+export class TaskExecutionChain extends LLMChain {
+    static fromLLM(fields) {
+        const executionTemplate = `You are an AI who performs one task based on the following objective: ` +
+            `{objective}.` +
+            `Take into account these previously completed tasks: {context}.` +
+            ` Your task: {task}. Response:`;
+        const prompt = new PromptTemplate({
+            template: executionTemplate,
+            inputVariables: ["objective", "context", "task"],
+        });
+        return new TaskExecutionChain({ prompt, ...fields });
+    }
+}

package/dist/experimental/babyagi/task_prioritization.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskPrioritizationChain = void 0;
+const llm_chain_js_1 = require("../../chains/llm_chain.cjs");
+const prompt_js_1 = require("../../prompts/prompt.cjs");
+/** Chain to prioritize tasks. */
+class TaskPrioritizationChain extends llm_chain_js_1.LLMChain {
+    static fromLLM(fields) {
+        const taskPrioritizationTemplate = `You are a task prioritization AI tasked with cleaning the formatting of ` +
+            `and reprioritizing the following tasks: {task_names}.` +
+            ` Consider the ultimate objective of your team: {objective}.` +
+            ` Do not remove any tasks. Return the result as a numbered list, like:` +
+            ` #. First task` +
+            ` #. Second task` +
+            ` Start the task list with number {next_task_id}.`;
+        const prompt = new prompt_js_1.PromptTemplate({
+            template: taskPrioritizationTemplate,
+            inputVariables: ["task_names", "next_task_id", "objective"],
+        });
+        return new TaskPrioritizationChain({ prompt, ...fields });
+    }
+}
+exports.TaskPrioritizationChain = TaskPrioritizationChain;

package/dist/experimental/babyagi/task_prioritization.d.ts

@@ -0,0 +1,5 @@
+import { LLMChain, LLMChainInput } from "../../chains/llm_chain.js";
+/** Chain to prioritize tasks. */
+export declare class TaskPrioritizationChain extends LLMChain {
+    static fromLLM(fields: Omit<LLMChainInput, "prompt">): LLMChain;
+}

package/dist/experimental/babyagi/task_prioritization.js

@@ -0,0 +1,19 @@
+import { LLMChain } from "../../chains/llm_chain.js";
+import { PromptTemplate } from "../../prompts/prompt.js";
+/** Chain to prioritize tasks. */
+export class TaskPrioritizationChain extends LLMChain {
+    static fromLLM(fields) {
+        const taskPrioritizationTemplate = `You are a task prioritization AI tasked with cleaning the formatting of ` +
+            `and reprioritizing the following tasks: {task_names}.` +
+            ` Consider the ultimate objective of your team: {objective}.` +
+            ` Do not remove any tasks. Return the result as a numbered list, like:` +
+            ` #. First task` +
+            ` #. Second task` +
+            ` Start the task list with number {next_task_id}.`;
+        const prompt = new PromptTemplate({
+            template: taskPrioritizationTemplate,
+            inputVariables: ["task_names", "next_task_id", "objective"],
+        });
+        return new TaskPrioritizationChain({ prompt, ...fields });
+    }
+}

package/dist/llms/base.cjs

@@ -11,15 +11,6 @@ const manager_js_1 = require("../callbacks/manager.cjs");
 class BaseLLM extends index_js_3.BaseLanguageModel {
     constructor({ cache, concurrency, ...rest }) {
         super(concurrency ? { maxConcurrency: concurrency, ...rest } : rest);
-        /**
-         * The name of the LLM class
-         */
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "cache", {
             enumerable: true,
             configurable: true,