langchain 0.0.197-rc.0 → 0.0.197-rc.1

package/dist/agents/executor.cjs

@@ -1,11 +1,215 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentExecutor = exports.ExceptionTool = void 0;
+exports.AgentExecutor = exports.ExceptionTool = exports.AgentExecutorIterator = void 0;
 const base_js_1 = require("../chains/base.cjs");
 const agent_js_1 = require("./agent.cjs");
+const manager_js_1 = require("../callbacks/manager.cjs");
 const output_parser_js_1 = require("../schema/output_parser.cjs");
 const base_js_2 = require("../tools/base.cjs");
 const base_js_3 = require("../schema/runnable/base.cjs");
+const serializable_js_1 = require("../load/serializable.cjs");
+class AgentExecutorIterator extends serializable_js_1.Serializable {
+    get finalOutputs() {
+        return this._finalOutputs;
+    }
+    /** Intended to be used as a setter method, needs to be async. */
+    async setFinalOutputs(value) {
+        this._finalOutputs = undefined;
+        if (value) {
+            const preparedOutputs = await this.agentExecutor.prepOutputs(this.inputs, value, true);
+            this._finalOutputs = preparedOutputs;
+        }
+    }
+    get nameToToolMap() {
+        const toolMap = this.agentExecutor.tools.map((tool) => ({
+            [tool.name]: tool,
+        }));
+        return Object.assign({}, ...toolMap);
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "agents", "executor_iterator"]
+        });
+        Object.defineProperty(this, "agentExecutor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "inputs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "callbacks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tags", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "metadata", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "runName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_finalOutputs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "runManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "intermediateSteps", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "iterations", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        this.agentExecutor = fields.agentExecutor;
+        this.inputs = fields.inputs;
+        this.tags = fields.tags;
+        this.metadata = fields.metadata;
+        this.runName = fields.runName;
+        this.runManager = fields.runManager;
+    }
+    /**
+     * Reset the iterator to its initial state, clearing intermediate steps,
+     * iterations, and the final output.
+     */
+    reset() {
+        this.intermediateSteps = [];
+        this.iterations = 0;
+        this._finalOutputs = undefined;
+    }
+    updateIterations() {
+        this.iterations += 1;
+    }
+    async *streamIterator() {
+        this.reset();
+        // Loop to handle iteration
+        while (true) {
+            try {
+                if (this.iterations === 0) {
+                    await this.onFirstStep();
+                }
+                const result = await this._callNext();
+                yield result;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (e) {
+                if ("message" in e &&
+                    e.message.startsWith("Final outputs already reached: ")) {
+                    if (!this.finalOutputs) {
+                        throw e;
+                    }
+                    return this.finalOutputs;
+                }
+                if (this.runManager) {
+                    await this.runManager.handleChainError(e);
+                }
+                throw e;
+            }
+        }
+    }
+    /**
+     * Perform any necessary setup for the first step
+     * of the asynchronous iterator.
+     */
+    async onFirstStep() {
+        if (this.iterations === 0) {
+            const callbackManager = await manager_js_1.CallbackManager.configure(this.callbacks, this.agentExecutor.callbacks, this.tags, this.agentExecutor.tags, this.metadata, this.agentExecutor.metadata, {
+                verbose: this.agentExecutor.verbose,
+            });
+            this.runManager = await callbackManager?.handleChainStart(this.agentExecutor.toJSON(), this.inputs, undefined, undefined, this.tags, this.metadata, this.runName);
+        }
+    }
+    /**
+     * Execute the next step in the chain using the
+     * AgentExecutor's _takeNextStep method.
+     */
+    async _executeNextStep(runManager) {
+        return this.agentExecutor._takeNextStep(this.nameToToolMap, this.inputs, this.intermediateSteps, runManager);
+    }
+    /**
+     * Process the output of the next step,
+     * handling AgentFinish and tool return cases.
+     */
+    async _processNextStepOutput(nextStepOutput, runManager) {
+        if ("returnValues" in nextStepOutput) {
+            const output = await this.agentExecutor._return(nextStepOutput, this.intermediateSteps, runManager);
+            if (this.runManager) {
+                await this.runManager.handleChainEnd(output);
+            }
+            await this.setFinalOutputs(output);
+            return output;
+        }
+        this.intermediateSteps = this.intermediateSteps.concat(nextStepOutput);
+        let output = {};
+        if (Array.isArray(nextStepOutput) && nextStepOutput.length === 1) {
+            const nextStep = nextStepOutput[0];
+            const toolReturn = await this.agentExecutor._getToolReturn(nextStep);
+            if (toolReturn) {
+                output = await this.agentExecutor._return(toolReturn, this.intermediateSteps, runManager);
+                if (this.runManager) {
+                    await this.runManager.handleChainEnd(output);
+                }
+                await this.setFinalOutputs(output);
+            }
+        }
+        output = { intermediateSteps: nextStepOutput };
+        return output;
+    }
+    async _stop() {
+        const output = await this.agentExecutor.agent.returnStoppedResponse(this.agentExecutor.earlyStoppingMethod, this.intermediateSteps, this.inputs);
+        const returnedOutput = await this.agentExecutor._return(output, this.intermediateSteps, this.runManager);
+        await this.setFinalOutputs(returnedOutput);
+        return returnedOutput;
+    }
+    async _callNext() {
+        // final output already reached: stopiteration (final output)
+        if (this.finalOutputs) {
+            throw new Error(`Final outputs already reached: ${JSON.stringify(this.finalOutputs, null, 2)}`);
+        }
+        // timeout/max iterations: stopiteration (stopped response)
+        if (!this.agentExecutor.shouldContinueGetter(this.iterations)) {
+            return this._stop();
+        }
+        const nextStepOutput = await this._executeNextStep(this.runManager);
+        const output = await this._processNextStepOutput(nextStepOutput, this.runManager);
+        this.updateIterations();
+        return output;
+    }
+}
+exports.AgentExecutorIterator = AgentExecutorIterator;
 /**
  * Tool that just returns the query.
  * Used for exception tracking.
@@ -138,6 +342,9 @@ class AgentExecutor extends base_js_1.BaseChain {
     static fromAgentAndTools(fields) {
         return new AgentExecutor(fields);
     }
+    get shouldContinueGetter() {
+        return this.shouldContinue.bind(this);
+    }
     /**
      * Method that checks if the agent execution should continue based on the
      * number of iterations.
@@ -257,6 +464,149 @@ class AgentExecutor extends base_js_1.BaseChain {
         const finish = await this.agent.returnStoppedResponse(this.earlyStoppingMethod, steps, inputs);
         return getOutput(finish);
     }
+    async _takeNextStep(nameToolMap, inputs, intermediateSteps, runManager) {
+        let output;
+        try {
+            output = await this.agent.plan(intermediateSteps, inputs, runManager?.getChild());
+        }
+        catch (e) {
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            if (e instanceof output_parser_js_1.OutputParserException) {
+                let observation;
+                let text = e.message;
+                if (this.handleParsingErrors === true) {
+                    if (e.sendToLLM) {
+                        observation = e.observation;
+                        text = e.llmOutput ?? "";
+                    }
+                    else {
+                        observation = "Invalid or incomplete response";
+                    }
+                }
+                else if (typeof this.handleParsingErrors === "string") {
+                    observation = this.handleParsingErrors;
+                }
+                else if (typeof this.handleParsingErrors === "function") {
+                    observation = this.handleParsingErrors(e);
+                }
+                else {
+                    throw e;
+                }
+                output = {
+                    tool: "_Exception",
+                    toolInput: observation,
+                    log: text,
+                };
+            }
+            else {
+                throw e;
+            }
+        }
+        if ("returnValues" in output) {
+            return output;
+        }
+        let actions;
+        if (Array.isArray(output)) {
+            actions = output;
+        }
+        else {
+            actions = [output];
+        }
+        const result = [];
+        for (const agentAction of actions) {
+            let observation = "";
+            if (runManager) {
+                await runManager?.handleAgentAction(agentAction);
+            }
+            if (agentAction.tool in nameToolMap) {
+                const tool = nameToolMap[agentAction.tool];
+                try {
+                    observation = await tool.call(agentAction.toolInput, runManager?.getChild());
+                }
+                catch (e) {
+                    // eslint-disable-next-line no-instanceof/no-instanceof
+                    if (e instanceof base_js_2.ToolInputParsingException) {
+                        if (this.handleParsingErrors === true) {
+                            observation =
+                                "Invalid or incomplete tool input. Please try again.";
+                        }
+                        else if (typeof this.handleParsingErrors === "string") {
+                            observation = this.handleParsingErrors;
+                        }
+                        else if (typeof this.handleParsingErrors === "function") {
+                            observation = this.handleParsingErrors(e);
+                        }
+                        else {
+                            throw e;
+                        }
+                        observation = await new ExceptionTool().call(observation, runManager?.getChild());
+                    }
+                }
+            }
+            else {
+                observation = `${agentAction.tool} is not a valid tool, try another available tool: ${Object.keys(nameToolMap).join(", ")}`;
+            }
+            result.push({
+                action: agentAction,
+                observation,
+            });
+        }
+        return result;
+    }
+    async _return(output, intermediateSteps, runManager) {
+        if (runManager) {
+            await runManager.handleAgentEnd(output);
+        }
+        const finalOutput = output.returnValues;
+        if (this.returnIntermediateSteps) {
+            finalOutput.intermediateSteps = intermediateSteps;
+        }
+        return finalOutput;
+    }
+    async _getToolReturn(nextStepOutput) {
+        const { action, observation } = nextStepOutput;
+        const nameToolMap = Object.fromEntries(this.tools.map((t) => [t.name.toLowerCase(), t]));
+        const [returnValueKey = "output"] = this.agent.returnValues;
+        // Invalid tools won't be in the map, so we return False.
+        if (action.tool in nameToolMap) {
+            if (nameToolMap[action.tool].returnDirect) {
+                return {
+                    returnValues: { [returnValueKey]: observation },
+                    log: "",
+                };
+            }
+        }
+        return null;
+    }
+    _returnStoppedResponse(earlyStoppingMethod) {
+        if (earlyStoppingMethod === "force") {
+            return {
+                returnValues: {
+                    output: "Agent stopped due to iteration limit or time limit.",
+                },
+                log: "",
+            };
+        }
+        throw new Error(`Got unsupported early_stopping_method: ${earlyStoppingMethod}`);
+    }
+    async *_streamIterator(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    inputs) {
+        const agentExecutorIterator = new AgentExecutorIterator({
+            inputs,
+            agentExecutor: this,
+            metadata: this.metadata,
+            tags: this.tags,
+            callbacks: this.callbacks,
+        });
+        const iterator = agentExecutorIterator.streamIterator();
+        for await (const step of iterator) {
+            if (!step) {
+                continue;
+            }
+            yield step;
+        }
+    }
     _chainType() {
         return "agent_executor";
     }

package/dist/agents/executor.d.ts

@@ -2,11 +2,63 @@ import { BaseChain, ChainInputs } from "../chains/base.js";
 import { BaseMultiActionAgent, BaseSingleActionAgent } from "./agent.js";
 import { StoppingMethod } from "./types.js";
 import { SerializedLLMChain } from "../chains/serde.js";
-import { AgentAction, AgentFinish, AgentStep, ChainValues } from "../schema/index.js";
-import { CallbackManagerForChainRun } from "../callbacks/manager.js";
+import { AgentAction, ChainValues, AgentFinish, AgentStep } from "../schema/index.js";
+import { CallbackManagerForChainRun, Callbacks } from "../callbacks/manager.js";
 import { OutputParserException } from "../schema/output_parser.js";
-import { StructuredTool, Tool, ToolInputParsingException } from "../tools/base.js";
+import { StructuredTool, ToolInputParsingException, Tool } from "../tools/base.js";
 import { Runnable } from "../schema/runnable/base.js";
+import { Serializable } from "../load/serializable.js";
+interface AgentExecutorIteratorInput {
+    agentExecutor: AgentExecutor;
+    inputs: Record<string, string>;
+    callbacks?: Callbacks;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    runName?: string;
+    runManager?: CallbackManagerForChainRun;
+}
+export declare class AgentExecutorIterator extends Serializable implements AgentExecutorIteratorInput {
+    lc_namespace: string[];
+    agentExecutor: AgentExecutor;
+    inputs: Record<string, string>;
+    callbacks: Callbacks;
+    tags: string[] | undefined;
+    metadata: Record<string, unknown> | undefined;
+    runName: string | undefined;
+    private _finalOutputs;
+    get finalOutputs(): Record<string, unknown> | undefined;
+    /** Intended to be used as a setter method, needs to be async. */
+    setFinalOutputs(value: Record<string, unknown> | undefined): Promise<void>;
+    runManager: CallbackManagerForChainRun | undefined;
+    intermediateSteps: AgentStep[];
+    iterations: number;
+    get nameToToolMap(): Record<string, Tool>;
+    constructor(fields: AgentExecutorIteratorInput);
+    /**
+     * Reset the iterator to its initial state, clearing intermediate steps,
+     * iterations, and the final output.
+     */
+    reset(): void;
+    updateIterations(): void;
+    streamIterator(): AsyncGenerator<Record<string, unknown>, Record<string, unknown>, unknown>;
+    /**
+     * Perform any necessary setup for the first step
+     * of the asynchronous iterator.
+     */
+    onFirstStep(): Promise<void>;
+    /**
+     * Execute the next step in the chain using the
+     * AgentExecutor's _takeNextStep method.
+     */
+    _executeNextStep(runManager?: CallbackManagerForChainRun): Promise<AgentFinish | AgentStep[]>;
+    /**
+     * Process the output of the next step,
+     * handling AgentFinish and tool return cases.
+     */
+    _processNextStepOutput(nextStepOutput: AgentFinish | AgentStep[], runManager?: CallbackManagerForChainRun): Promise<Record<string, string | AgentStep[]>>;
+    _stop(): Promise<Record<string, unknown>>;
+    _callNext(): Promise<Record<string, unknown>>;
+}
 type ExtractToolType<T> = T extends {
     ToolType: infer Tool;
 } ? Tool : StructuredTool;
@@ -77,6 +129,7 @@ export declare class AgentExecutor extends BaseChain<ChainValues, AgentExecutorO
     constructor(input: AgentExecutorInput);
     /** Create from agent and a list of tools. */
     static fromAgentAndTools(fields: AgentExecutorInput): AgentExecutor;
+    get shouldContinueGetter(): (iterations: number) => boolean;
     /**
      * Method that checks if the agent execution should continue based on the
      * number of iterations.
@@ -86,6 +139,11 @@ export declare class AgentExecutor extends BaseChain<ChainValues, AgentExecutorO
     private shouldContinue;
     /** @ignore */
     _call(inputs: ChainValues, runManager?: CallbackManagerForChainRun): Promise<AgentExecutorOutput>;
+    _takeNextStep(nameToolMap: Record<string, Tool>, inputs: ChainValues, intermediateSteps: AgentStep[], runManager?: CallbackManagerForChainRun): Promise<AgentFinish | AgentStep[]>;
+    _return(output: AgentFinish, intermediateSteps: AgentStep[], runManager?: CallbackManagerForChainRun): Promise<AgentExecutorOutput>;
+    _getToolReturn(nextStepOutput: AgentStep): Promise<AgentFinish | null>;
+    _returnStoppedResponse(earlyStoppingMethod: StoppingMethod): AgentFinish;
+    _streamIterator(inputs: Record<string, any>): AsyncGenerator<ChainValues>;
     _chainType(): "agent_executor";
     serialize(): SerializedLLMChain;
 }