langchain 0.0.195 → 0.0.197-rc.0

package/dist/prompts/pipeline.js

@@ -1,140 +1 @@
-import { BasePromptTemplate } from "./base.js";
-import { ChatPromptTemplate } from "./chat.js";
-/**
- * Class that handles a sequence of prompts, each of which may require
- * different input variables. Includes methods for formatting these
- * prompts, extracting required input values, and handling partial
- * prompts.
- * @example
- * ```typescript
- * const composedPrompt = new PipelinePromptTemplate({
- *   pipelinePrompts: [
- *     {
- *       name: "introduction",
- *       prompt: PromptTemplate.fromTemplate(`You are impersonating {person}.`),
- *     },
- *     {
- *       name: "example",
- *       prompt: PromptTemplate.fromTemplate(
- *         `Here's an example of an interaction:
- * Q: {example_q}
- * A: {example_a}`,
- *       ),
- *     },
- *     {
- *       name: "start",
- *       prompt: PromptTemplate.fromTemplate(
- *         `Now, do this for real!
- * Q: {input}
- * A:`,
- *       ),
- *     },
- *   ],
- *   finalPrompt: PromptTemplate.fromTemplate(
- *     `{introduction}
- * {example}
- * {start}`,
- *   ),
- * });
- *
- * const formattedPrompt = await composedPrompt.format({
- *   person: "Elon Musk",
- *   example_q: `What's your favorite car?`,
- *   example_a: "Tesla",
- *   input: `What's your favorite social media site?`,
- * });
- * ```
- */
-export class PipelinePromptTemplate extends BasePromptTemplate {
-    static lc_name() {
-        return "PipelinePromptTemplate";
-    }
-    constructor(input) {
-        super({ ...input, inputVariables: [] });
-        Object.defineProperty(this, "pipelinePrompts", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "finalPrompt", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.pipelinePrompts = input.pipelinePrompts;
-        this.finalPrompt = input.finalPrompt;
-        this.inputVariables = this.computeInputValues();
-    }
-    /**
-     * Computes the input values required by the pipeline prompts.
-     * @returns Array of input values required by the pipeline prompts.
-     */
-    computeInputValues() {
-        const intermediateValues = this.pipelinePrompts.map((pipelinePrompt) => pipelinePrompt.name);
-        const inputValues = this.pipelinePrompts
-            .map((pipelinePrompt) => pipelinePrompt.prompt.inputVariables.filter((inputValue) => !intermediateValues.includes(inputValue)))
-            .flat();
-        return [...new Set(inputValues)];
-    }
-    static extractRequiredInputValues(allValues, requiredValueNames) {
-        return requiredValueNames.reduce((requiredValues, valueName) => {
-            // eslint-disable-next-line no-param-reassign
-            requiredValues[valueName] = allValues[valueName];
-            return requiredValues;
-        }, {});
-    }
-    /**
-     * Formats the pipeline prompts based on the provided input values.
-     * @param values Input values to format the pipeline prompts.
-     * @returns Promise that resolves with the formatted input values.
-     */
-    async formatPipelinePrompts(values) {
-        const allValues = await this.mergePartialAndUserVariables(values);
-        for (const { name: pipelinePromptName, prompt: pipelinePrompt } of this
-            .pipelinePrompts) {
-            const pipelinePromptInputValues = PipelinePromptTemplate.extractRequiredInputValues(allValues, pipelinePrompt.inputVariables);
-            // eslint-disable-next-line no-instanceof/no-instanceof
-            if (pipelinePrompt instanceof ChatPromptTemplate) {
-                allValues[pipelinePromptName] = await pipelinePrompt.formatMessages(pipelinePromptInputValues);
-            }
-            else {
-                allValues[pipelinePromptName] = await pipelinePrompt.format(pipelinePromptInputValues);
-            }
-        }
-        return PipelinePromptTemplate.extractRequiredInputValues(allValues, this.finalPrompt.inputVariables);
-    }
-    /**
-     * Formats the final prompt value based on the provided input values.
-     * @param values Input values to format the final prompt value.
-     * @returns Promise that resolves with the formatted final prompt value.
-     */
-    async formatPromptValue(values) {
-        return this.finalPrompt.formatPromptValue(await this.formatPipelinePrompts(values));
-    }
-    async format(values) {
-        return this.finalPrompt.format(await this.formatPipelinePrompts(values));
-    }
-    /**
-     * Handles partial prompts, which are prompts that have been partially
-     * filled with input values.
-     * @param values Partial input values.
-     * @returns Promise that resolves with a new PipelinePromptTemplate instance with updated input variables.
-     */
-    async partial(values) {
-        const promptDict = { ...this };
-        promptDict.inputVariables = this.inputVariables.filter((iv) => !(iv in values));
-        promptDict.partialVariables = {
-            ...(this.partialVariables ?? {}),
-            ...values,
-        };
-        return new PipelinePromptTemplate(promptDict);
-    }
-    serialize() {
-        throw new Error("Not implemented.");
-    }
-    _getPromptType() {
-        return "pipeline";
-    }
-}
+export { PipelinePromptTemplate, } from "langchain-core/prompts";

package/dist/prompts/prompt.cjs

@@ -1,148 +1,5 @@
 "use strict";
-// Default generic "any" values are for backwards compatibility.
-// Replace with "string" when we are comfortable with a breaking change.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptTemplate = void 0;
-const base_js_1 = require("./base.cjs");
-const template_js_1 = require("./template.cjs");
-/**
- * Schema to represent a basic prompt for an LLM.
- * @augments BasePromptTemplate
- * @augments PromptTemplateInput
- *
- * @example
- * ```ts
- * import { PromptTemplate } from "langchain/prompts";
- *
- * const prompt = new PromptTemplate({
- *   inputVariables: ["foo"],
- *   template: "Say {foo}",
- * });
- * ```
- */
-class PromptTemplate extends base_js_1.BaseStringPromptTemplate {
-    static lc_name() {
-        return "PromptTemplate";
-    }
-    constructor(input) {
-        super(input);
-        Object.defineProperty(this, "template", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "templateFormat", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "f-string"
-        });
-        Object.defineProperty(this, "validateTemplate", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.assign(this, input);
-        if (this.validateTemplate) {
-            let totalInputVariables = this.inputVariables;
-            if (this.partialVariables) {
-                totalInputVariables = totalInputVariables.concat(Object.keys(this.partialVariables));
-            }
-            (0, template_js_1.checkValidTemplate)(this.template, this.templateFormat, totalInputVariables);
-        }
-    }
-    _getPromptType() {
-        return "prompt";
-    }
-    /**
-     * Formats the prompt template with the provided values.
-     * @param values The values to be used to format the prompt template.
-     * @returns A promise that resolves to a string which is the formatted prompt.
-     */
-    async format(values) {
-        const allValues = await this.mergePartialAndUserVariables(values);
-        return (0, template_js_1.renderTemplate)(this.template, this.templateFormat, allValues);
-    }
-    /**
-     * Take examples in list format with prefix and suffix to create a prompt.
-     *
-     * Intended to be used a a way to dynamically create a prompt from examples.
-     *
-     * @param examples - List of examples to use in the prompt.
-     * @param suffix - String to go after the list of examples. Should generally set up the user's input.
-     * @param inputVariables - A list of variable names the final prompt template will expect
-     * @param exampleSeparator - The separator to use in between examples
-     * @param prefix - String that should go before any examples. Generally includes examples.
-     *
-     * @returns The final prompt template generated.
-     */
-    static fromExamples(examples, suffix, inputVariables, exampleSeparator = "\n\n", prefix = "") {
-        const template = [prefix, ...examples, suffix].join(exampleSeparator);
-        return new PromptTemplate({
-            inputVariables,
-            template,
-        });
-    }
-    /**
-     * Load prompt template from a template f-string
-     */
-    static fromTemplate(template, { templateFormat = "f-string", ...rest } = {}) {
-        const names = new Set();
-        (0, template_js_1.parseTemplate)(template, templateFormat).forEach((node) => {
-            if (node.type === "variable") {
-                names.add(node.name);
-            }
-        });
-        return new PromptTemplate({
-            // Rely on extracted types
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            inputVariables: [...names],
-            templateFormat,
-            template,
-            ...rest,
-        });
-    }
-    /**
-     * Partially applies values to the prompt template.
-     * @param values The values to be partially applied to the prompt template.
-     * @returns A new instance of PromptTemplate with the partially applied values.
-     */
-    async partial(values) {
-        const newInputVariables = this.inputVariables.filter((iv) => !(iv in values));
-        const newPartialVariables = {
-            ...(this.partialVariables ?? {}),
-            ...values,
-        };
-        const promptDict = {
-            ...this,
-            inputVariables: newInputVariables,
-            partialVariables: newPartialVariables,
-        };
-        return new PromptTemplate(promptDict);
-    }
-    serialize() {
-        if (this.outputParser !== undefined) {
-            throw new Error("Cannot serialize a prompt template with an output parser");
-        }
-        return {
-            _type: this._getPromptType(),
-            input_variables: this.inputVariables,
-            template: this.template,
-            template_format: this.templateFormat,
-        };
-    }
-    static async deserialize(data) {
-        if (!data.template) {
-            throw new Error("Prompt template must have a template");
-        }
-        const res = new PromptTemplate({
-            inputVariables: data.input_variables,
-            template: data.template,
-            templateFormat: data.template_format,
-        });
-        return res;
-    }
-}
-exports.PromptTemplate = PromptTemplate;
+var prompts_1 = require("langchain-core/prompts");
+Object.defineProperty(exports, "PromptTemplate", { enumerable: true, get: function () { return prompts_1.PromptTemplate; } });

package/dist/prompts/prompt.d.ts

@@ -1,92 +1 @@
-import { BaseStringPromptTemplate, BasePromptTemplateInput, TypedPromptInputValues } from "./base.js";
-import { TemplateFormat } from "./template.js";
-import { SerializedPromptTemplate } from "./serde.js";
-import { InputValues, PartialValues } from "../schema/index.js";
-/**
- * Inputs to create a {@link PromptTemplate}
- * @augments BasePromptTemplateInput
- */
-export interface PromptTemplateInput<RunInput extends InputValues = any, PartialVariableName extends string = any> extends BasePromptTemplateInput<RunInput, PartialVariableName> {
-    /**
-     * The prompt template
-     */
-    template: string;
-    /**
-     * The format of the prompt template. Options are 'f-string'
-     *
-     * @defaultValue 'f-string'
-     */
-    templateFormat?: TemplateFormat;
-    /**
-     * Whether or not to try validating the template on initialization
-     *
-     * @defaultValue `true`
-     */
-    validateTemplate?: boolean;
-}
-type NonAlphanumeric = " " | "\t" | "\n" | "\r" | '"' | "'" | "{" | "[" | "(" | "`" | ":" | ";";
-/**
- * Recursive type to extract template parameters from a string.
- * @template T - The input string.
- * @template Result - The resulting array of extracted template parameters.
- */
-type ExtractTemplateParamsRecursive<T extends string, Result extends string[] = []> = T extends `${string}{${infer Param}}${infer Rest}` ? Param extends `${NonAlphanumeric}${string}` ? ExtractTemplateParamsRecursive<Rest, Result> : ExtractTemplateParamsRecursive<Rest, [...Result, Param]> : Result;
-export type ParamsFromFString<T extends string> = {
-    [Key in ExtractTemplateParamsRecursive<T>[number] | (string & Record<never, never>)]: string;
-};
-/**
- * Schema to represent a basic prompt for an LLM.
- * @augments BasePromptTemplate
- * @augments PromptTemplateInput
- *
- * @example
- * ```ts
- * import { PromptTemplate } from "langchain/prompts";
- *
- * const prompt = new PromptTemplate({
- *   inputVariables: ["foo"],
- *   template: "Say {foo}",
- * });
- * ```
- */
-export declare class PromptTemplate<RunInput extends InputValues = any, PartialVariableName extends string = any> extends BaseStringPromptTemplate<RunInput, PartialVariableName> implements PromptTemplateInput<RunInput, PartialVariableName> {
-    static lc_name(): string;
-    template: string;
-    templateFormat: TemplateFormat;
-    validateTemplate: boolean;
-    constructor(input: PromptTemplateInput<RunInput, PartialVariableName>);
-    _getPromptType(): "prompt";
-    /**
-     * Formats the prompt template with the provided values.
-     * @param values The values to be used to format the prompt template.
-     * @returns A promise that resolves to a string which is the formatted prompt.
-     */
-    format(values: TypedPromptInputValues<RunInput>): Promise<string>;
-    /**
-     * Take examples in list format with prefix and suffix to create a prompt.
-     *
-     * Intended to be used a a way to dynamically create a prompt from examples.
-     *
-     * @param examples - List of examples to use in the prompt.
-     * @param suffix - String to go after the list of examples. Should generally set up the user's input.
-     * @param inputVariables - A list of variable names the final prompt template will expect
-     * @param exampleSeparator - The separator to use in between examples
-     * @param prefix - String that should go before any examples. Generally includes examples.
-     *
-     * @returns The final prompt template generated.
-     */
-    static fromExamples(examples: string[], suffix: string, inputVariables: string[], exampleSeparator?: string, prefix?: string): PromptTemplate<any, any>;
-    /**
-     * Load prompt template from a template f-string
-     */
-    static fromTemplate<RunInput extends InputValues = Symbol, T extends string = string>(template: T, { templateFormat, ...rest }?: Omit<PromptTemplateInput<RunInput, string>, "template" | "inputVariables">): PromptTemplate<RunInput extends Symbol ? ParamsFromFString<T> : RunInput, any>;
-    /**
-     * Partially applies values to the prompt template.
-     * @param values The values to be partially applied to the prompt template.
-     * @returns A new instance of PromptTemplate with the partially applied values.
-     */
-    partial<NewPartialVariableName extends string>(values: PartialValues<NewPartialVariableName>): Promise<PromptTemplate<InputValues<Exclude<Extract<keyof RunInput, string>, NewPartialVariableName>>, any>>;
-    serialize(): SerializedPromptTemplate;
-    static deserialize(data: SerializedPromptTemplate): Promise<PromptTemplate>;
-}
-export {};
+export { type PromptTemplateInput, type ParamsFromFString, PromptTemplate, } from "langchain-core/prompts";

package/dist/prompts/prompt.js

@@ -1,144 +1 @@
-// Default generic "any" values are for backwards compatibility.
-// Replace with "string" when we are comfortable with a breaking change.
-import { BaseStringPromptTemplate, } from "./base.js";
-import { checkValidTemplate, parseTemplate, renderTemplate, } from "./template.js";
-/**
- * Schema to represent a basic prompt for an LLM.
- * @augments BasePromptTemplate
- * @augments PromptTemplateInput
- *
- * @example
- * ```ts
- * import { PromptTemplate } from "langchain/prompts";
- *
- * const prompt = new PromptTemplate({
- *   inputVariables: ["foo"],
- *   template: "Say {foo}",
- * });
- * ```
- */
-export class PromptTemplate extends BaseStringPromptTemplate {
-    static lc_name() {
-        return "PromptTemplate";
-    }
-    constructor(input) {
-        super(input);
-        Object.defineProperty(this, "template", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "templateFormat", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "f-string"
-        });
-        Object.defineProperty(this, "validateTemplate", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.assign(this, input);
-        if (this.validateTemplate) {
-            let totalInputVariables = this.inputVariables;
-            if (this.partialVariables) {
-                totalInputVariables = totalInputVariables.concat(Object.keys(this.partialVariables));
-            }
-            checkValidTemplate(this.template, this.templateFormat, totalInputVariables);
-        }
-    }
-    _getPromptType() {
-        return "prompt";
-    }
-    /**
-     * Formats the prompt template with the provided values.
-     * @param values The values to be used to format the prompt template.
-     * @returns A promise that resolves to a string which is the formatted prompt.
-     */
-    async format(values) {
-        const allValues = await this.mergePartialAndUserVariables(values);
-        return renderTemplate(this.template, this.templateFormat, allValues);
-    }
-    /**
-     * Take examples in list format with prefix and suffix to create a prompt.
-     *
-     * Intended to be used a a way to dynamically create a prompt from examples.
-     *
-     * @param examples - List of examples to use in the prompt.
-     * @param suffix - String to go after the list of examples. Should generally set up the user's input.
-     * @param inputVariables - A list of variable names the final prompt template will expect
-     * @param exampleSeparator - The separator to use in between examples
-     * @param prefix - String that should go before any examples. Generally includes examples.
-     *
-     * @returns The final prompt template generated.
-     */
-    static fromExamples(examples, suffix, inputVariables, exampleSeparator = "\n\n", prefix = "") {
-        const template = [prefix, ...examples, suffix].join(exampleSeparator);
-        return new PromptTemplate({
-            inputVariables,
-            template,
-        });
-    }
-    /**
-     * Load prompt template from a template f-string
-     */
-    static fromTemplate(template, { templateFormat = "f-string", ...rest } = {}) {
-        const names = new Set();
-        parseTemplate(template, templateFormat).forEach((node) => {
-            if (node.type === "variable") {
-                names.add(node.name);
-            }
-        });
-        return new PromptTemplate({
-            // Rely on extracted types
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            inputVariables: [...names],
-            templateFormat,
-            template,
-            ...rest,
-        });
-    }
-    /**
-     * Partially applies values to the prompt template.
-     * @param values The values to be partially applied to the prompt template.
-     * @returns A new instance of PromptTemplate with the partially applied values.
-     */
-    async partial(values) {
-        const newInputVariables = this.inputVariables.filter((iv) => !(iv in values));
-        const newPartialVariables = {
-            ...(this.partialVariables ?? {}),
-            ...values,
-        };
-        const promptDict = {
-            ...this,
-            inputVariables: newInputVariables,
-            partialVariables: newPartialVariables,
-        };
-        return new PromptTemplate(promptDict);
-    }
-    serialize() {
-        if (this.outputParser !== undefined) {
-            throw new Error("Cannot serialize a prompt template with an output parser");
-        }
-        return {
-            _type: this._getPromptType(),
-            input_variables: this.inputVariables,
-            template: this.template,
-            template_format: this.templateFormat,
-        };
-    }
-    static async deserialize(data) {
-        if (!data.template) {
-            throw new Error("Prompt template must have a template");
-        }
-        const res = new PromptTemplate({
-            inputVariables: data.input_variables,
-            template: data.template,
-            templateFormat: data.template_format,
-        });
-        return res;
-    }
-}
+export { PromptTemplate, } from "langchain-core/prompts";

package/dist/prompts/selectors/LengthBasedExampleSelector.cjs

@@ -1,150 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LengthBasedExampleSelector = void 0;
-const base_js_1 = require("../base.cjs");
-/**
- * Calculates the length of a text based on the number of words and lines.
- */
-function getLengthBased(text) {
-    return text.split(/\n| /).length;
-}
-/**
- * A specialized example selector that selects examples based on their
- * length, ensuring that the total length of the selected examples does
- * not exceed a specified maximum length.
- * @example
- * ```typescript
- * const exampleSelector = new LengthBasedExampleSelector(
- *   [
- *     { input: "happy", output: "sad" },
- *     { input: "tall", output: "short" },
- *     { input: "energetic", output: "lethargic" },
- *     { input: "sunny", output: "gloomy" },
- *     { input: "windy", output: "calm" },
- *   ],
- *   {
- *     examplePrompt: new PromptTemplate({
- *       inputVariables: ["input", "output"],
- *       template: "Input: {input}\nOutput: {output}",
- *     }),
- *     maxLength: 25,
- *   },
- * );
- * const dynamicPrompt = new FewShotPromptTemplate({
- *   exampleSelector,
- *   examplePrompt: new PromptTemplate({
- *     inputVariables: ["input", "output"],
- *     template: "Input: {input}\nOutput: {output}",
- *   }),
- *   prefix: "Give the antonym of every input",
- *   suffix: "Input: {adjective}\nOutput:",
- *   inputVariables: ["adjective"],
- * });
- * console.log(dynamicPrompt.format({ adjective: "big" }));
- * console.log(
- *   dynamicPrompt.format({
- *     adjective:
- *       "big and huge and massive and large and gigantic and tall and much much much much much bigger than everything else",
- *   }),
- * );
- * ```
- */
-class LengthBasedExampleSelector extends base_js_1.BaseExampleSelector {
-    constructor(data) {
-        super(data);
-        Object.defineProperty(this, "examples", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "examplePrompt", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "getTextLength", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: getLengthBased
-        });
-        Object.defineProperty(this, "maxLength", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 2048
-        });
-        Object.defineProperty(this, "exampleTextLengths", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        this.examplePrompt = data.examplePrompt;
-        this.maxLength = data.maxLength ?? 2048;
-        this.getTextLength = data.getTextLength ?? getLengthBased;
-    }
-    /**
-     * Adds an example to the list of examples and calculates its length.
-     * @param example The example to be added.
-     * @returns Promise that resolves when the example has been added and its length calculated.
-     */
-    async addExample(example) {
-        this.examples.push(example);
-        const stringExample = await this.examplePrompt.format(example);
-        this.exampleTextLengths.push(this.getTextLength(stringExample));
-    }
-    /**
-     * Calculates the lengths of the examples.
-     * @param v Array of lengths of the examples.
-     * @param values Instance of LengthBasedExampleSelector.
-     * @returns Promise that resolves with an array of lengths of the examples.
-     */
-    async calculateExampleTextLengths(v, values) {
-        if (v.length > 0) {
-            return v;
-        }
-        const { examples, examplePrompt } = values;
-        const stringExamples = await Promise.all(examples.map((eg) => examplePrompt.format(eg)));
-        return stringExamples.map((eg) => this.getTextLength(eg));
-    }
-    /**
-     * Selects examples until the total length of the selected examples
-     * reaches the maxLength.
-     * @param inputVariables The input variables for the examples.
-     * @returns Promise that resolves with an array of selected examples.
-     */
-    async selectExamples(inputVariables) {
-        const inputs = Object.values(inputVariables).join(" ");
-        let remainingLength = this.maxLength - this.getTextLength(inputs);
-        let i = 0;
-        const examples = [];
-        while (remainingLength > 0 && i < this.examples.length) {
-            const newLength = remainingLength - this.exampleTextLengths[i];
-            if (newLength < 0) {
-                break;
-            }
-            else {
-                examples.push(this.examples[i]);
-                remainingLength = newLength;
-            }
-            i += 1;
-        }
-        return examples;
-    }
-    /**
-     * Creates a new instance of LengthBasedExampleSelector and adds a list of
-     * examples to it.
-     * @param examples Array of examples to be added.
-     * @param args Input parameters for the LengthBasedExampleSelector.
-     * @returns Promise that resolves with a new instance of LengthBasedExampleSelector with the examples added.
-     */
-    static async fromExamples(examples, args) {
-        const selector = new LengthBasedExampleSelector(args);
-        await Promise.all(examples.map((eg) => selector.addExample(eg)));
-        return selector;
-    }
-}
-exports.LengthBasedExampleSelector = LengthBasedExampleSelector;
+var example_selectors_1 = require("langchain-core/example_selectors");
+Object.defineProperty(exports, "LengthBasedExampleSelector", { enumerable: true, get: function () { return example_selectors_1.LengthBasedExampleSelector; } });