langchain 0.0.147 → 0.0.149

package/dist/evaluation/agents/prompt.cjs

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * Prompt for trajectory evaluation chain.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_FREE_EVAL_CHAT_PROMPT = exports.EVAL_CHAT_PROMPT = void 0;
+const index_js_1 = require("../../prompts/index.cjs");
+const EVAL_TEMPLATE = `An AI language model has been given access to the following set of tools to help answer a user's question.
+
+The tools given to the AI model are:
+[TOOL_DESCRIPTIONS]
+{toolDescriptions}
+[END_TOOL_DESCRIPTIONS]
+
+The question the human asked the AI model was:
+[QUESTION]
+{question}
+[END_QUESTION]{reference}
+
+The AI language model decided to use the following set of tools to answer the question:
+[AGENT_TRAJECTORY]
+{agentTrajectory}
+[END_AGENT_TRAJECTORY]
+
+The AI language model's final answer to the question was:
+[RESPONSE]
+{answer}
+[END_RESPONSE]
+
+Let's do a detailed evaluation of the AI language model's answer step by step.
+
+We consider the following criteria before giving a score from 1 to 5:
+
+i. Is the final answer helpful?
+ii. Does the AI language use a logical sequence of tools to answer the question?
+iii. Does the AI language model use the tools in a helpful way?
+iv. Does the AI language model use too many steps to answer the question?
+v. Are the appropriate tools used to answer the question?`;
+const EXAMPLE_INPUT = `An AI language model has been given access to the following set of tools to help answer a user's question.
+
+The tools given to the AI model are:
+[TOOL_DESCRIPTIONS]
+Tool 1:
+Name: Search
+Description: useful for when you need to ask with search
+
+Tool 2:
+Name: Lookup
+Description: useful for when you need to ask with lookup
+
+Tool 3:
+Name: Calculator
+Description: useful for doing calculations
+
+Tool 4:
+Name: Search the Web (SerpAPI)
+Description: useful for when you need to answer questions about current events
+[END_TOOL_DESCRIPTIONS]
+
+The question the human asked the AI model was: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?
+
+    The AI language model decided to use the following set of tools to answer the question:
+[AGENT_TRAJECTORY]
+Step 1:
+Tool used: Search the Web (SerpAPI)
+Tool input: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?
+Tool output: The Statue of Liberty was given to the United States by France, as a symbol of the two countries' friendship. It was erected atop an American-designed ...
+[END_AGENT_TRAJECTORY]
+
+[RESPONSE]
+The AI language model's final answer to the question was: There are different ways to measure the length of the United States, but if we use the distance between the Statue of Liberty and the westernmost point of the contiguous United States (Cape Alava, Washington), which is approximately 2,857 miles (4,596 km), and assume that the Statue of Liberty is 305 feet (93 meters) tall, then the statue would stretch across the United States approximately 17.5 times if laid end to end.
+[END_RESPONSE]
+
+Let's do a detailed evaluation of the AI language model's answer step by step.
+
+We consider the following criteria before giving a score from 1 to 5:
+
+i. Is the final answer helpful?
+ii. Does the AI language use a logical sequence of tools to answer the question?
+iii. Does the AI language model use the tools in a helpful way?
+iv. Does the AI language model use too many steps to answer the question?
+v. Are the appropriate tools used to answer the question?`;
+const EXAMPLE_OUTPUT = `First, let's evaluate the final answer. The final uses good reasoning but is wrong. 2,857 divided by 305 is not 17.5.\
+The model should have used the calculator to figure this out. Second does the model use a logical sequence of tools to answer the question?\
+The way model uses the search is not helpful. The model should have used the search tool to figure the width of the US or the height of the statue.\
+The model didn't use the calculator tool and gave an incorrect answer. The search API should be used for current events or specific questions.\
+The tools were not used in a helpful way. The model did not use too many steps to answer the question.\
+The model did not use the appropriate tools to answer the question.\
+
+Judgment: Given the good reasoning in the final answer but otherwise poor performance, we give the model a score of 2.
+
+Score: 2`;
+exports.EVAL_CHAT_PROMPT = 
+/* #__PURE__ */ index_js_1.ChatPromptTemplate.fromPromptMessages([
+    /* #__PURE__ */ index_js_1.SystemMessagePromptTemplate.fromTemplate("You are a helpful assistant that evaluates language models."),
+    /* #__PURE__ */ index_js_1.HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),
+    /* #__PURE__ */ index_js_1.AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),
+    /* #__PURE__ */ index_js_1.HumanMessagePromptTemplate.fromTemplate(EVAL_TEMPLATE),
+]);
+const TOOL_FREE_EVAL_TEMPLATE = `An AI language model has been given access to a set of tools to help answer a user's question.
+
+The question the human asked the AI model was:
+[QUESTION]
+{question}
+[END_QUESTION]{reference}
+
+The AI language model decided to use the following set of tools to answer the question:
+[AGENT_TRAJECTORY]
+{agentTrajectory}
+[END_AGENT_TRAJECTORY]
+
+The AI language model's final answer to the question was:
+[RESPONSE]
+{answer}
+[END_RESPONSE]
+
+Let's do a detailed evaluation of the AI language model's answer step by step.
+
+We consider the following criteria before giving a score from 1 to 5:
+
+i. Is the final answer helpful?
+    ii. Does the AI language use a logical sequence of tools to answer the question?
+    iii. Does the AI language model use the tools in a helpful way?
+    iv. Does the AI language model use too many steps to answer the question?
+    v. Are the appropriate tools used to answer the question?`;
+exports.TOOL_FREE_EVAL_CHAT_PROMPT = 
+/* #__PURE__ */ index_js_1.ChatPromptTemplate.fromPromptMessages([
+    /* #__PURE__ */ index_js_1.SystemMessagePromptTemplate.fromTemplate("You are a helpful assistant that evaluates language models."),
+    /* #__PURE__ */ index_js_1.HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),
+    /* #__PURE__ */ index_js_1.AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),
+    /* #__PURE__ */ index_js_1.HumanMessagePromptTemplate.fromTemplate(TOOL_FREE_EVAL_TEMPLATE),
+]);

package/dist/evaluation/agents/prompt.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Prompt for trajectory evaluation chain.
+ */
+import { ChatPromptTemplate } from "../../prompts/index.js";
+export declare const EVAL_CHAT_PROMPT: ChatPromptTemplate<any, any>;
+export declare const TOOL_FREE_EVAL_CHAT_PROMPT: ChatPromptTemplate<any, any>;

package/dist/evaluation/agents/prompt.js

@@ -0,0 +1,129 @@
+/**
+ * Prompt for trajectory evaluation chain.
+ */
+import { AIMessagePromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate, } from "../../prompts/index.js";
+const EVAL_TEMPLATE = `An AI language model has been given access to the following set of tools to help answer a user's question.
+
+The tools given to the AI model are:
+[TOOL_DESCRIPTIONS]
+{toolDescriptions}
+[END_TOOL_DESCRIPTIONS]
+
+The question the human asked the AI model was:
+[QUESTION]
+{question}
+[END_QUESTION]{reference}
+
+The AI language model decided to use the following set of tools to answer the question:
+[AGENT_TRAJECTORY]
+{agentTrajectory}
+[END_AGENT_TRAJECTORY]
+
+The AI language model's final answer to the question was:
+[RESPONSE]
+{answer}
+[END_RESPONSE]
+
+Let's do a detailed evaluation of the AI language model's answer step by step.
+
+We consider the following criteria before giving a score from 1 to 5:
+
+i. Is the final answer helpful?
+ii. Does the AI language use a logical sequence of tools to answer the question?
+iii. Does the AI language model use the tools in a helpful way?
+iv. Does the AI language model use too many steps to answer the question?
+v. Are the appropriate tools used to answer the question?`;
+const EXAMPLE_INPUT = `An AI language model has been given access to the following set of tools to help answer a user's question.
+
+The tools given to the AI model are:
+[TOOL_DESCRIPTIONS]
+Tool 1:
+Name: Search
+Description: useful for when you need to ask with search
+
+Tool 2:
+Name: Lookup
+Description: useful for when you need to ask with lookup
+
+Tool 3:
+Name: Calculator
+Description: useful for doing calculations
+
+Tool 4:
+Name: Search the Web (SerpAPI)
+Description: useful for when you need to answer questions about current events
+[END_TOOL_DESCRIPTIONS]
+
+The question the human asked the AI model was: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?
+
+    The AI language model decided to use the following set of tools to answer the question:
+[AGENT_TRAJECTORY]
+Step 1:
+Tool used: Search the Web (SerpAPI)
+Tool input: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?
+Tool output: The Statue of Liberty was given to the United States by France, as a symbol of the two countries' friendship. It was erected atop an American-designed ...
+[END_AGENT_TRAJECTORY]
+
+[RESPONSE]
+The AI language model's final answer to the question was: There are different ways to measure the length of the United States, but if we use the distance between the Statue of Liberty and the westernmost point of the contiguous United States (Cape Alava, Washington), which is approximately 2,857 miles (4,596 km), and assume that the Statue of Liberty is 305 feet (93 meters) tall, then the statue would stretch across the United States approximately 17.5 times if laid end to end.
+[END_RESPONSE]
+
+Let's do a detailed evaluation of the AI language model's answer step by step.
+
+We consider the following criteria before giving a score from 1 to 5:
+
+i. Is the final answer helpful?
+ii. Does the AI language use a logical sequence of tools to answer the question?
+iii. Does the AI language model use the tools in a helpful way?
+iv. Does the AI language model use too many steps to answer the question?
+v. Are the appropriate tools used to answer the question?`;
+const EXAMPLE_OUTPUT = `First, let's evaluate the final answer. The final uses good reasoning but is wrong. 2,857 divided by 305 is not 17.5.\
+The model should have used the calculator to figure this out. Second does the model use a logical sequence of tools to answer the question?\
+The way model uses the search is not helpful. The model should have used the search tool to figure the width of the US or the height of the statue.\
+The model didn't use the calculator tool and gave an incorrect answer. The search API should be used for current events or specific questions.\
+The tools were not used in a helpful way. The model did not use too many steps to answer the question.\
+The model did not use the appropriate tools to answer the question.\
+
+Judgment: Given the good reasoning in the final answer but otherwise poor performance, we give the model a score of 2.
+
+Score: 2`;
+export const EVAL_CHAT_PROMPT = 
+/* #__PURE__ */ ChatPromptTemplate.fromPromptMessages([
+    /* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate("You are a helpful assistant that evaluates language models."),
+    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),
+    /* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),
+    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EVAL_TEMPLATE),
+]);
+const TOOL_FREE_EVAL_TEMPLATE = `An AI language model has been given access to a set of tools to help answer a user's question.
+
+The question the human asked the AI model was:
+[QUESTION]
+{question}
+[END_QUESTION]{reference}
+
+The AI language model decided to use the following set of tools to answer the question:
+[AGENT_TRAJECTORY]
+{agentTrajectory}
+[END_AGENT_TRAJECTORY]
+
+The AI language model's final answer to the question was:
+[RESPONSE]
+{answer}
+[END_RESPONSE]
+
+Let's do a detailed evaluation of the AI language model's answer step by step.
+
+We consider the following criteria before giving a score from 1 to 5:
+
+i. Is the final answer helpful?
+    ii. Does the AI language use a logical sequence of tools to answer the question?
+    iii. Does the AI language model use the tools in a helpful way?
+    iv. Does the AI language model use too many steps to answer the question?
+    v. Are the appropriate tools used to answer the question?`;
+export const TOOL_FREE_EVAL_CHAT_PROMPT = 
+/* #__PURE__ */ ChatPromptTemplate.fromPromptMessages([
+    /* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate("You are a helpful assistant that evaluates language models."),
+    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),
+    /* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),
+    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(TOOL_FREE_EVAL_TEMPLATE),
+]);

package/dist/evaluation/agents/trajectory.cjs

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrajectoryEvalChain = exports.TrajectoryOutputParser = void 0;
+const output_parser_js_1 = require("../../schema/output_parser.cjs");
+const base_js_1 = require("../base.cjs");
+const index_js_1 = require("../../schema/index.cjs");
+const prompt_js_1 = require("./prompt.cjs");
+/**
+ * A parser for the output of the TrajectoryEvalChain.
+ */
+class TrajectoryOutputParser extends output_parser_js_1.BaseLLMOutputParser {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "evaluation", "agents"]
+        });
+    }
+    static lc_name() {
+        return "TrajectoryOutputParser";
+    }
+    parseResult(generations, _callbacks) {
+        const { text } = generations[0];
+        if (!text.includes("Score:")) {
+            throw new Error(`Could not find score in model eval output: ${text}`);
+        }
+        let [reasoning, scoreStr] = text.split("Score:", 2);
+        reasoning = reasoning.trim();
+        scoreStr = scoreStr.trim();
+        // Use regex to extract the score.
+        // This will get the number in the string, even if it is a float or more than 10.
+        // E.g. "Score: 1" will return 1, "Score: 3.5" will return 3.5, and
+        // "Score: 10" will return 10.
+        // The score should be an integer digit in the range 1-5.
+        const scoreMatch = scoreStr.match(/(\d+(\.\d+)?)/);
+        if (scoreMatch === null || scoreMatch[1].includes(".")) {
+            throw new Error(`Score is not an integer digit in the range 1-5: ${text}`);
+        }
+        const score = +scoreMatch[1];
+        if (score < 1 || score > 5) {
+            throw new Error(`Score is not a digit in the range 1-5: ${text}`);
+        }
+        const normalizedScore = (score - 1) / 4;
+        return Promise.resolve({
+            reasoning,
+            score: normalizedScore,
+        });
+    }
+}
+exports.TrajectoryOutputParser = TrajectoryOutputParser;
+/**
+ * A chain for evaluating ReAct style agents.
+ *
+ * This chain is used to evaluate ReAct style agents by reasoning about
+ * the sequence of actions taken and their outcomes.
+ */
+class TrajectoryEvalChain extends base_js_1.AgentTrajectoryEvaluator {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "criterionName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "evaluationName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: this.criterionName
+        });
+        Object.defineProperty(this, "requiresInput", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "requiresReference", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "outputParser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new TrajectoryOutputParser()
+        });
+    }
+    static lc_name() {
+        return "TrajectoryEvalChain";
+    }
+    static resolveTrajectoryPrompt(prompt, agentTools) {
+        let _prompt;
+        if (prompt) {
+            _prompt = prompt;
+        }
+        else if (agentTools) {
+            _prompt = prompt_js_1.EVAL_CHAT_PROMPT;
+        }
+        else {
+            _prompt = prompt_js_1.TOOL_FREE_EVAL_CHAT_PROMPT;
+        }
+        return _prompt;
+    }
+    /**
+     * Get the description of the agent tools.
+     *
+     * @returns The description of the agent tools.
+     */
+    static toolsDescription(agentTools) {
+        return agentTools
+            .map((tool, i) => `Tool ${i + 1}: ${tool.name}\n Description: ${tool.description}`)
+            .join("\n\n");
+    }
+    /**
+     * Create a new TrajectoryEvalChain.
+     * @param llm
+     * @param agentTools - The tools used by the agent.
+     * @param chainOptions - The options for the chain.
+     */
+    static async fromLLM(llm, agentTools, chainOptions) {
+        let prompt = this.resolveTrajectoryPrompt(chainOptions?.prompt, agentTools);
+        if (agentTools) {
+            const toolDescriptions = this.toolsDescription(agentTools);
+            prompt = await prompt.partial({ toolDescriptions });
+        }
+        const options = chainOptions;
+        if (options) {
+            // remove prompt from chainOptions
+            delete options.prompt;
+        }
+        return new this({
+            llm,
+            prompt,
+            ...options,
+        });
+    }
+    _prepareOutput(result) {
+        const parsed = result[this.outputKey];
+        if (index_js_1.RUN_KEY in result && result[index_js_1.RUN_KEY]) {
+            parsed[index_js_1.RUN_KEY] = result[index_js_1.RUN_KEY];
+        }
+        return parsed;
+    }
+    /**
+     * Get the agent trajectory as a formatted string.
+     *
+     * @param steps - The agent trajectory.
+     * @returns The formatted agent trajectory.
+     */
+    getAgentTrajectory(steps) {
+        return steps
+            .map((step, i) => {
+            const { action, observation } = step;
+            return (`Step ${i + 1}:\n` +
+                `Tool used: ${action.tool}\n` +
+                `Tool input: ${action.toolInput}\n` +
+                `Tool output: ${observation}`);
+        })
+            .join("\n\n");
+    }
+    formatReference(reference) {
+        if (!reference) {
+            return "";
+        }
+        return `
+The following is the expected answer. Use this to measure correctness:
+[GROUND_TRUTH]
+${reference}
+[END_GROUND_TRUTH]
+        `;
+    }
+    async _evaluateAgentTrajectory(args, callOptions, config) {
+        const { input, prediction, reference, agentTrajectory } = args;
+        const inputs = {
+            question: input,
+            agentTrajectory: this.getAgentTrajectory(agentTrajectory),
+            answer: prediction,
+            reference: this.formatReference(reference),
+        };
+        const result = await this.call({ ...inputs, ...callOptions }, config);
+        return this._prepareOutput(result);
+    }
+}
+exports.TrajectoryEvalChain = TrajectoryEvalChain;

package/dist/evaluation/agents/trajectory.d.ts

@@ -0,0 +1,54 @@
+import { BaseLLMOutputParser } from "../../schema/output_parser.js";
+import { AgentTrajectoryEvaluator, EvalOutputType, LLMEvalChainInput, LLMTrajectoryEvaluatorArgs } from "../base.js";
+import { AgentStep, ChainValues, ChatGeneration, Generation } from "../../schema/index.js";
+import { Callbacks } from "../../callbacks/index.js";
+import { BaseCallbackConfig } from "../../callbacks/manager.js";
+import { BasePromptTemplate } from "../../prompts/index.js";
+import { StructuredTool } from "../../tools/index.js";
+import { BaseChatModel } from "../../chat_models/base.js";
+/**
+ * A parser for the output of the TrajectoryEvalChain.
+ */
+export declare class TrajectoryOutputParser extends BaseLLMOutputParser<EvalOutputType> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;
+}
+/**
+ * A chain for evaluating ReAct style agents.
+ *
+ * This chain is used to evaluate ReAct style agents by reasoning about
+ * the sequence of actions taken and their outcomes.
+ */
+export declare class TrajectoryEvalChain extends AgentTrajectoryEvaluator {
+    static lc_name(): string;
+    criterionName?: string;
+    evaluationName?: string;
+    requiresInput: boolean;
+    requiresReference: boolean;
+    outputParser: TrajectoryOutputParser;
+    static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredTool[]): import("../../prompts/chat.js").ChatPromptTemplate<any, any> | BasePromptTemplate<any, import("../../schema/index.js").BasePromptValue, any>;
+    /**
+     * Get the description of the agent tools.
+     *
+     * @returns The description of the agent tools.
+     */
+    static toolsDescription(agentTools: StructuredTool[]): string;
+    /**
+     * Create a new TrajectoryEvalChain.
+     * @param llm
+     * @param agentTools - The tools used by the agent.
+     * @param chainOptions - The options for the chain.
+     */
+    static fromLLM(llm: BaseChatModel, agentTools?: StructuredTool[], chainOptions?: Partial<Omit<LLMEvalChainInput, "llm">>): Promise<TrajectoryEvalChain>;
+    _prepareOutput(result: ChainValues): any;
+    /**
+     * Get the agent trajectory as a formatted string.
+     *
+     * @param steps - The agent trajectory.
+     * @returns The formatted agent trajectory.
+     */
+    getAgentTrajectory(steps: AgentStep[]): string;
+    formatReference(reference?: string): string;
+    _evaluateAgentTrajectory(args: LLMTrajectoryEvaluatorArgs, callOptions: this["llm"]["CallOptions"], config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;
+}