langchain 0.0.167 → 0.0.169

package/dist/chat_models/fake.cjs

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeListChatModel = void 0;
+const base_js_1 = require("./base.cjs");
+const index_js_1 = require("../schema/index.cjs");
+/**
+ * A fake Chat Model that returns a predefined list of responses. It can be used
+ * for testing purposes.
+ */
+class FakeListChatModel extends base_js_1.BaseChatModel {
+    static lc_name() {
+        return "FakeListChatModel";
+    }
+    constructor({ responses, sleep }) {
+        super({});
+        Object.defineProperty(this, "responses", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "i", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "sleep", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.responses = responses;
+        this.sleep = sleep;
+    }
+    _combineLLMOutput() {
+        return [];
+    }
+    _llmType() {
+        return "fake-list";
+    }
+    async _generate(_messages, options) {
+        await this._sleepIfRequested();
+        if (options?.stop?.length) {
+            return {
+                generations: [this._formatGeneration(options.stop[0])],
+            };
+        }
+        else {
+            const response = this._currentResponse();
+            this._incrementResponse();
+            return {
+                generations: [this._formatGeneration(response)],
+                llmOutput: {},
+            };
+        }
+    }
+    _formatGeneration(text) {
+        return {
+            message: new index_js_1.AIMessage(text),
+            text,
+        };
+    }
+    async *_streamResponseChunks(_messages, _options, _runManager) {
+        const response = this._currentResponse();
+        this._incrementResponse();
+        for await (const text of response) {
+            await this._sleepIfRequested();
+            yield this._createResponseChunk(text);
+        }
+    }
+    async _sleepIfRequested() {
+        if (this.sleep !== undefined) {
+            await this._sleep();
+        }
+    }
+    async _sleep() {
+        return new Promise((resolve) => {
+            setTimeout(() => resolve(), this.sleep);
+        });
+    }
+    _createResponseChunk(text) {
+        return new index_js_1.ChatGenerationChunk({
+            message: new index_js_1.AIMessageChunk({ content: text }),
+            text,
+        });
+    }
+    _currentResponse() {
+        return this.responses[this.i];
+    }
+    _incrementResponse() {
+        if (this.i < this.responses.length - 1) {
+            this.i += 1;
+        }
+        else {
+            this.i = 0;
+        }
+    }
+}
+exports.FakeListChatModel = FakeListChatModel;

package/dist/chat_models/fake.d.ts

@@ -0,0 +1,36 @@
+import { BaseChatModel, BaseChatModelParams } from "./base.js";
+import { AIMessage, BaseMessage, ChatGenerationChunk, ChatResult } from "../schema/index.js";
+import { CallbackManagerForLLMRun } from "../callbacks/manager.js";
+/**
+ * Interface for the input parameters specific to the Fake List Chat model.
+ */
+export interface FakeChatInput extends BaseChatModelParams {
+    /** Responses to return */
+    responses: string[];
+    /** Time to sleep in milliseconds between responses */
+    sleep?: number;
+}
+/**
+ * A fake Chat Model that returns a predefined list of responses. It can be used
+ * for testing purposes.
+ */
+export declare class FakeListChatModel extends BaseChatModel {
+    static lc_name(): string;
+    responses: string[];
+    i: number;
+    sleep?: number;
+    constructor({ responses, sleep }: FakeChatInput);
+    _combineLLMOutput(): never[];
+    _llmType(): string;
+    _generate(_messages: BaseMessage[], options?: this["ParsedCallOptions"]): Promise<ChatResult>;
+    _formatGeneration(text: string): {
+        message: AIMessage;
+        text: string;
+    };
+    _streamResponseChunks(_messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    _sleepIfRequested(): Promise<void>;
+    _sleep(): Promise<void>;
+    _createResponseChunk(text: string): ChatGenerationChunk;
+    _currentResponse(): string;
+    _incrementResponse(): void;
+}

package/dist/chat_models/fake.js

@@ -0,0 +1,97 @@
+import { BaseChatModel } from "./base.js";
+import { AIMessage, AIMessageChunk, ChatGenerationChunk, } from "../schema/index.js";
+/**
+ * A fake Chat Model that returns a predefined list of responses. It can be used
+ * for testing purposes.
+ */
+export class FakeListChatModel extends BaseChatModel {
+    static lc_name() {
+        return "FakeListChatModel";
+    }
+    constructor({ responses, sleep }) {
+        super({});
+        Object.defineProperty(this, "responses", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "i", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "sleep", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.responses = responses;
+        this.sleep = sleep;
+    }
+    _combineLLMOutput() {
+        return [];
+    }
+    _llmType() {
+        return "fake-list";
+    }
+    async _generate(_messages, options) {
+        await this._sleepIfRequested();
+        if (options?.stop?.length) {
+            return {
+                generations: [this._formatGeneration(options.stop[0])],
+            };
+        }
+        else {
+            const response = this._currentResponse();
+            this._incrementResponse();
+            return {
+                generations: [this._formatGeneration(response)],
+                llmOutput: {},
+            };
+        }
+    }
+    _formatGeneration(text) {
+        return {
+            message: new AIMessage(text),
+            text,
+        };
+    }
+    async *_streamResponseChunks(_messages, _options, _runManager) {
+        const response = this._currentResponse();
+        this._incrementResponse();
+        for await (const text of response) {
+            await this._sleepIfRequested();
+            yield this._createResponseChunk(text);
+        }
+    }
+    async _sleepIfRequested() {
+        if (this.sleep !== undefined) {
+            await this._sleep();
+        }
+    }
+    async _sleep() {
+        return new Promise((resolve) => {
+            setTimeout(() => resolve(), this.sleep);
+        });
+    }
+    _createResponseChunk(text) {
+        return new ChatGenerationChunk({
+            message: new AIMessageChunk({ content: text }),
+            text,
+        });
+    }
+    _currentResponse() {
+        return this.responses[this.i];
+    }
+    _incrementResponse() {
+        if (this.i < this.responses.length - 1) {
+            this.i += 1;
+        }
+        else {
+            this.i = 0;
+        }
+    }
+}

package/dist/chat_models/yandex.cjs

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatYandexGPT = void 0;
+const index_js_1 = require("../schema/index.cjs");
+const env_js_1 = require("../util/env.cjs");
+const base_js_1 = require("./base.cjs");
+const apiUrl = "https://llm.api.cloud.yandex.net/llm/v1alpha/chat";
+function _parseChatHistory(history) {
+    const chatHistory = [];
+    let instruction = "";
+    for (const message of history) {
+        if ("content" in message) {
+            if (message._getType() === "human") {
+                chatHistory.push({ role: "user", text: message.content });
+            }
+            else if (message._getType() === "ai") {
+                chatHistory.push({ role: "assistant", text: message.content });
+            }
+            else if (message._getType() === "system") {
+                instruction = message.content;
+            }
+        }
+    }
+    return [chatHistory, instruction];
+}
+class ChatYandexGPT extends base_js_1.BaseChatModel {
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "apiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "iamToken", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "temperature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0.6
+        });
+        Object.defineProperty(this, "maxTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1700
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "general"
+        });
+        const apiKey = fields?.apiKey ?? (0, env_js_1.getEnvironmentVariable)("YC_API_KEY");
+        const iamToken = fields?.iamToken ?? (0, env_js_1.getEnvironmentVariable)("YC_IAM_TOKEN");
+        if (apiKey === undefined && iamToken === undefined) {
+            throw new Error("Please set the YC_API_KEY or YC_IAM_TOKEN environment variable or pass it to the constructor as the apiKey or iamToken field.");
+        }
+        this.apiKey = apiKey;
+        this.iamToken = iamToken;
+        this.maxTokens = fields?.maxTokens ?? this.maxTokens;
+        this.temperature = fields?.temperature ?? this.temperature;
+        this.model = fields?.model ?? this.model;
+    }
+    _llmType() {
+        return "yandexgpt";
+    }
+    _combineLLMOutput() {
+        return {};
+    }
+    /** @ignore */
+    async _generate(messages, options, _) {
+        const [messageHistory, instruction] = _parseChatHistory(messages);
+        const headers = { "Content-Type": "application/json", Authorization: "" };
+        if (this.apiKey !== undefined) {
+            headers.Authorization = `Api-Key ${this.apiKey}`;
+        }
+        else {
+            headers.Authorization = `Bearer ${this.iamToken}`;
+        }
+        const bodyData = {
+            model: this.model,
+            generationOptions: {
+                temperature: this.temperature,
+                maxTokens: this.maxTokens,
+            },
+            messages: messageHistory,
+            instructionText: instruction,
+        };
+        const response = await fetch(apiUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(bodyData),
+            signal: options?.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${apiUrl} from YandexGPT: ${response.status}`);
+        }
+        const responseData = await response.json();
+        const { result } = responseData;
+        const { text } = result.message;
+        const totalTokens = result.num_tokens;
+        const generations = [
+            { text, message: new index_js_1.AIMessage(text) },
+        ];
+        return {
+            generations,
+            llmOutput: { totalTokens },
+        };
+    }
+}
+exports.ChatYandexGPT = ChatYandexGPT;

package/dist/chat_models/yandex.d.ts

@@ -0,0 +1,16 @@
+import { CallbackManagerForLLMRun } from "../callbacks/manager.js";
+import { YandexGPTInputs } from "../llms/yandex.js";
+import { BaseMessage, ChatResult } from "../schema/index.js";
+import { BaseChatModel } from "./base.js";
+export declare class ChatYandexGPT extends BaseChatModel {
+    apiKey?: string;
+    iamToken?: string;
+    temperature: number;
+    maxTokens: number;
+    model: string;
+    constructor(fields?: YandexGPTInputs);
+    _llmType(): string;
+    _combineLLMOutput?(): {};
+    /** @ignore */
+    _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], _?: CallbackManagerForLLMRun | undefined): Promise<ChatResult>;
+}

package/dist/chat_models/yandex.js

@@ -0,0 +1,113 @@
+import { AIMessage, } from "../schema/index.js";
+import { getEnvironmentVariable } from "../util/env.js";
+import { BaseChatModel } from "./base.js";
+const apiUrl = "https://llm.api.cloud.yandex.net/llm/v1alpha/chat";
+function _parseChatHistory(history) {
+    const chatHistory = [];
+    let instruction = "";
+    for (const message of history) {
+        if ("content" in message) {
+            if (message._getType() === "human") {
+                chatHistory.push({ role: "user", text: message.content });
+            }
+            else if (message._getType() === "ai") {
+                chatHistory.push({ role: "assistant", text: message.content });
+            }
+            else if (message._getType() === "system") {
+                instruction = message.content;
+            }
+        }
+    }
+    return [chatHistory, instruction];
+}
+export class ChatYandexGPT extends BaseChatModel {
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "apiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "iamToken", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "temperature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0.6
+        });
+        Object.defineProperty(this, "maxTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1700
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "general"
+        });
+        const apiKey = fields?.apiKey ?? getEnvironmentVariable("YC_API_KEY");
+        const iamToken = fields?.iamToken ?? getEnvironmentVariable("YC_IAM_TOKEN");
+        if (apiKey === undefined && iamToken === undefined) {
+            throw new Error("Please set the YC_API_KEY or YC_IAM_TOKEN environment variable or pass it to the constructor as the apiKey or iamToken field.");
+        }
+        this.apiKey = apiKey;
+        this.iamToken = iamToken;
+        this.maxTokens = fields?.maxTokens ?? this.maxTokens;
+        this.temperature = fields?.temperature ?? this.temperature;
+        this.model = fields?.model ?? this.model;
+    }
+    _llmType() {
+        return "yandexgpt";
+    }
+    _combineLLMOutput() {
+        return {};
+    }
+    /** @ignore */
+    async _generate(messages, options, _) {
+        const [messageHistory, instruction] = _parseChatHistory(messages);
+        const headers = { "Content-Type": "application/json", Authorization: "" };
+        if (this.apiKey !== undefined) {
+            headers.Authorization = `Api-Key ${this.apiKey}`;
+        }
+        else {
+            headers.Authorization = `Bearer ${this.iamToken}`;
+        }
+        const bodyData = {
+            model: this.model,
+            generationOptions: {
+                temperature: this.temperature,
+                maxTokens: this.maxTokens,
+            },
+            messages: messageHistory,
+            instructionText: instruction,
+        };
+        const response = await fetch(apiUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(bodyData),
+            signal: options?.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${apiUrl} from YandexGPT: ${response.status}`);
+        }
+        const responseData = await response.json();
+        const { result } = responseData;
+        const { text } = result.message;
+        const totalTokens = result.num_tokens;
+        const generations = [
+            { text, message: new AIMessage(text) },
+        ];
+        return {
+            generations,
+            llmOutput: { totalTokens },
+        };
+    }
+}

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

@@ -8,14 +8,14 @@
 import { PromptTemplate } from "../../prompts/index.js";
 export declare const PROMPT: PromptTemplate<{
     input: any;
-    criteria: any;
     prediction: any;
+    criteria: any;
     predictionB: any;
 }, any>;
 export declare const PROMPT_WITH_REFERENCES: PromptTemplate<{
     input: any;
+    prediction: any;
     criteria: any;
     reference: any;
-    prediction: any;
     predictionB: any;
 }, any>;

package/dist/experimental/chains/violation_of_expectations/index.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViolationOfExpectationsChain = void 0;
+var violation_of_expectations_chain_js_1 = require("./violation_of_expectations_chain.cjs");
+Object.defineProperty(exports, "ViolationOfExpectationsChain", { enumerable: true, get: function () { return violation_of_expectations_chain_js_1.ViolationOfExpectationsChain; } });

package/dist/experimental/chains/violation_of_expectations/index.d.ts

@@ -0,0 +1 @@
+export { type ViolationOfExpectationsChainInput, ViolationOfExpectationsChain, } from "./violation_of_expectations_chain.js";

package/dist/experimental/chains/violation_of_expectations/index.js

@@ -0,0 +1 @@
+export { ViolationOfExpectationsChain, } from "./violation_of_expectations_chain.js";

package/dist/experimental/chains/violation_of_expectations/types.cjs

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PREDICTION_VIOLATIONS_FUNCTION = exports.PREDICT_NEXT_USER_MESSAGE_FUNCTION = void 0;
+exports.PREDICT_NEXT_USER_MESSAGE_FUNCTION = {
+    name: "predictNextUserMessage",
+    description: "Predicts the next user message, along with insights.",
+    parameters: {
+        type: "object",
+        properties: {
+            userState: {
+                type: "string",
+                description: "Concise reasoning about the users internal mental state.",
+            },
+            predictedUserMessage: {
+                type: "string",
+                description: "Your prediction on how they will respond to the AI's most recent message.",
+            },
+            insights: {
+                type: "array",
+                items: {
+                    type: "string",
+                },
+                description: "A concise list of any additional insights that would be useful to improve prediction.",
+            },
+        },
+        required: ["userState", "predictedUserMessage", "insights"],
+    },
+};
+exports.PREDICTION_VIOLATIONS_FUNCTION = {
+    name: "predictionViolations",
+    description: "Generates violations, errors and differences between the predicted user response, and the actual response.",
+    parameters: {
+        type: "object",
+        properties: {
+            violationExplanation: {
+                type: "string",
+                description: "How was the predication violated?",
+            },
+            explainedPredictionErrors: {
+                type: "array",
+                items: {
+                    type: "string",
+                },
+                description: "Explanations of how the prediction was violated and why",
+            },
+        },
+        required: ["violationExplanation", "explainedPredictionErrors"],
+    },
+};

package/dist/experimental/chains/violation_of_expectations/types.d.ts

@@ -0,0 +1,69 @@
+import { BaseMessage, HumanMessage } from "../../../schema/index.js";
+/**
+ * Contains the chunk of messages, along with the
+ * users response, which is the next message after the chunk.
+ */
+export type MessageChunkResult = {
+    chunkedMessages: BaseMessage[];
+    /**
+     * User response can be undefined if the last message in
+     * the chat history was from the AI.
+     */
+    userResponse?: HumanMessage;
+};
+export type PredictNextUserMessageResponse = {
+    userState: string;
+    predictedUserMessage: string;
+    insights: Array<string>;
+};
+export type GetPredictionViolationsResponse = {
+    userResponse?: HumanMessage;
+    revisedPrediction: string;
+    explainedPredictionErrors: Array<string>;
+};
+export declare const PREDICT_NEXT_USER_MESSAGE_FUNCTION: {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            userState: {
+                type: string;
+                description: string;
+            };
+            predictedUserMessage: {
+                type: string;
+                description: string;
+            };
+            insights: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare const PREDICTION_VIOLATIONS_FUNCTION: {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            violationExplanation: {
+                type: string;
+                description: string;
+            };
+            explainedPredictionErrors: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};

package/dist/experimental/chains/violation_of_expectations/types.js

@@ -0,0 +1,46 @@
+export const PREDICT_NEXT_USER_MESSAGE_FUNCTION = {
+    name: "predictNextUserMessage",
+    description: "Predicts the next user message, along with insights.",
+    parameters: {
+        type: "object",
+        properties: {
+            userState: {
+                type: "string",
+                description: "Concise reasoning about the users internal mental state.",
+            },
+            predictedUserMessage: {
+                type: "string",
+                description: "Your prediction on how they will respond to the AI's most recent message.",
+            },
+            insights: {
+                type: "array",
+                items: {
+                    type: "string",
+                },
+                description: "A concise list of any additional insights that would be useful to improve prediction.",
+            },
+        },
+        required: ["userState", "predictedUserMessage", "insights"],
+    },
+};
+export const PREDICTION_VIOLATIONS_FUNCTION = {
+    name: "predictionViolations",
+    description: "Generates violations, errors and differences between the predicted user response, and the actual response.",
+    parameters: {
+        type: "object",
+        properties: {
+            violationExplanation: {
+                type: "string",
+                description: "How was the predication violated?",
+            },
+            explainedPredictionErrors: {
+                type: "array",
+                items: {
+                    type: "string",
+                },
+                description: "Explanations of how the prediction was violated and why",
+            },
+        },
+        required: ["violationExplanation", "explainedPredictionErrors"],
+    },
+};