langchain 0.0.159 → 0.0.161

package/dist/embeddings/bedrock.cjs

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BedrockEmbeddings = void 0;
+const client_bedrock_runtime_1 = require("@aws-sdk/client-bedrock-runtime");
+const base_js_1 = require("./base.cjs");
+/**
+ * Class that extends the Embeddings class and provides methods for
+ * generating embeddings using the Bedrock API.
+ */
+class BedrockEmbeddings extends base_js_1.Embeddings {
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.model = fields?.model ?? "amazon.titan-embed-text-v1";
+        this.client =
+            fields?.client ??
+                new client_bedrock_runtime_1.BedrockRuntimeClient({
+                    region: fields?.region,
+                    credentials: fields?.credentials,
+                });
+    }
+    async _embedText(text) {
+        // replace newlines, which can negatively affect performance.
+        const cleanedText = text.replace(/\n/g, " ");
+        const res = await this.client.send(new client_bedrock_runtime_1.InvokeModelCommand({
+            modelId: this.model,
+            body: JSON.stringify({
+                inputText: cleanedText,
+            }),
+            contentType: "application/json",
+            accept: "application/json",
+        }));
+        try {
+            const body = new TextDecoder().decode(res.body);
+            return JSON.parse(body).embedding;
+        }
+        catch (e) {
+            throw new Error("An invalid response was returned by Bedrock.");
+        }
+    }
+    /**
+     * Method that takes a document as input and returns a promise that
+     * resolves to an embedding for the document. It calls the _embedText
+     * method with the document as the input.
+     * @param document Document for which to generate an embedding.
+     * @returns Promise that resolves to an embedding for the input document.
+     */
+    embedQuery(document) {
+        return this.caller.callWithOptions({}, this._embedText.bind(this), document);
+    }
+    /**
+     * Method that takes an array of documents as input and returns a promise
+     * that resolves to a 2D array of embeddings for each document. It calls
+     * the _embedText method for each document in the array.
+     * @param documents Array of documents for which to generate embeddings.
+     * @returns Promise that resolves to a 2D array of embeddings for each input document.
+     */
+    embedDocuments(documents) {
+        return Promise.all(documents.map((document) => this._embedText(document)));
+    }
+}
+exports.BedrockEmbeddings = BedrockEmbeddings;

package/dist/embeddings/bedrock.d.ts

@@ -0,0 +1,47 @@
+import { BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";
+import { Embeddings, EmbeddingsParams } from "./base.js";
+import type { CredentialType } from "../util/bedrock.js";
+/**
+ * Interface that extends EmbeddingsParams and defines additional
+ * parameters specific to the BedrockEmbeddings class.
+ */
+export interface BedrockEmbeddingsParams extends EmbeddingsParams {
+    /**
+     * Model Name to use. Defaults to `amazon.titan-embed-text-v1` if not provided
+     *
+     */
+    model?: string;
+    /**
+     * A client provided by the user that allows them to customze any
+     * SDK configuration options.
+     */
+    client?: BedrockRuntimeClient;
+    region?: string;
+    credentials?: CredentialType;
+}
+/**
+ * Class that extends the Embeddings class and provides methods for
+ * generating embeddings using the Bedrock API.
+ */
+export declare class BedrockEmbeddings extends Embeddings implements BedrockEmbeddingsParams {
+    model: string;
+    client: BedrockRuntimeClient;
+    constructor(fields?: BedrockEmbeddingsParams);
+    protected _embedText(text: string): Promise<number[]>;
+    /**
+     * Method that takes a document as input and returns a promise that
+     * resolves to an embedding for the document. It calls the _embedText
+     * method with the document as the input.
+     * @param document Document for which to generate an embedding.
+     * @returns Promise that resolves to an embedding for the input document.
+     */
+    embedQuery(document: string): Promise<number[]>;
+    /**
+     * Method that takes an array of documents as input and returns a promise
+     * that resolves to a 2D array of embeddings for each document. It calls
+     * the _embedText method for each document in the array.
+     * @param documents Array of documents for which to generate embeddings.
+     * @returns Promise that resolves to a 2D array of embeddings for each input document.
+     */
+    embedDocuments(documents: string[]): Promise<number[][]>;
+}

package/dist/embeddings/bedrock.js

@@ -0,0 +1,69 @@
+import { BedrockRuntimeClient, InvokeModelCommand, } from "@aws-sdk/client-bedrock-runtime";
+import { Embeddings } from "./base.js";
+/**
+ * Class that extends the Embeddings class and provides methods for
+ * generating embeddings using the Bedrock API.
+ */
+export class BedrockEmbeddings extends Embeddings {
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.model = fields?.model ?? "amazon.titan-embed-text-v1";
+        this.client =
+            fields?.client ??
+                new BedrockRuntimeClient({
+                    region: fields?.region,
+                    credentials: fields?.credentials,
+                });
+    }
+    async _embedText(text) {
+        // replace newlines, which can negatively affect performance.
+        const cleanedText = text.replace(/\n/g, " ");
+        const res = await this.client.send(new InvokeModelCommand({
+            modelId: this.model,
+            body: JSON.stringify({
+                inputText: cleanedText,
+            }),
+            contentType: "application/json",
+            accept: "application/json",
+        }));
+        try {
+            const body = new TextDecoder().decode(res.body);
+            return JSON.parse(body).embedding;
+        }
+        catch (e) {
+            throw new Error("An invalid response was returned by Bedrock.");
+        }
+    }
+    /**
+     * Method that takes a document as input and returns a promise that
+     * resolves to an embedding for the document. It calls the _embedText
+     * method with the document as the input.
+     * @param document Document for which to generate an embedding.
+     * @returns Promise that resolves to an embedding for the input document.
+     */
+    embedQuery(document) {
+        return this.caller.callWithOptions({}, this._embedText.bind(this), document);
+    }
+    /**
+     * Method that takes an array of documents as input and returns a promise
+     * that resolves to a 2D array of embeddings for each document. It calls
+     * the _embedText method for each document in the array.
+     * @param documents Array of documents for which to generate embeddings.
+     * @returns Promise that resolves to a 2D array of embeddings for each input document.
+     */
+    embedDocuments(documents) {
+        return Promise.all(documents.map((document) => this._embedText(document)));
+    }
+}

package/dist/experimental/hubs/makersuite/googlemakersuitehub.cjs

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MakerSuiteHub = exports.DriveFileReadConnection = exports.MakerSuitePrompt = void 0;
+const google_auth_library_1 = require("google-auth-library");
+const googlepalm_js_1 = require("../../../llms/googlepalm.cjs");
+const googlepalm_js_2 = require("../../../chat_models/googlepalm.cjs");
+const index_js_1 = require("../../../prompts/index.cjs");
+const async_caller_js_1 = require("../../../util/async_caller.cjs");
+const googlevertexai_connection_js_1 = require("../../../util/googlevertexai-connection.cjs");
+/**
+ * A class that represents the Prompt that has been created by MakerSuite
+ * and loaded from Google Drive. It exposes methods to turn this prompt
+ * into a Template, a Model, and into a chain consisting of these two elements.
+ * In general, this class should be created by the MakerSuiteHub class and
+ * not instantiated manually.
+ */
+class MakerSuitePrompt {
+    constructor(promptData) {
+        Object.defineProperty(this, "promptType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "promptData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.promptData = promptData;
+        this._determinePromptType();
+    }
+    _determinePromptType() {
+        if (Object.hasOwn(this.promptData, "textPrompt")) {
+            this.promptType = "text";
+        }
+        else if (Object.hasOwn(this.promptData, "dataPrompt")) {
+            this.promptType = "data";
+        }
+        else if (Object.hasOwn(this.promptData, "multiturnPrompt")) {
+            this.promptType = "chat";
+        }
+        else {
+            const error = new Error("Unable to identify prompt type.");
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            error.promptData = this.promptData;
+            throw error;
+        }
+    }
+    _promptValueText() {
+        return (this.promptData?.textPrompt?.value ?? "");
+    }
+    _promptValueData() {
+        const promptData = this
+            .promptData;
+        const dataPrompt = promptData?.dataPrompt;
+        let prompt = `${dataPrompt?.preamble}\n` || "";
+        dataPrompt?.rows.forEach((row) => {
+            // Add the data for each row, as long as it is listed as used
+            if (dataPrompt?.rowsUsed.includes(row.rowId)) {
+                // Add each input column
+                dataPrompt?.columns.forEach((column) => {
+                    if (column.isInput) {
+                        prompt += `${column.displayName} ${row.columnBindings[column.columnId]}\n`;
+                    }
+                });
+                // Add each output column
+                dataPrompt?.columns.forEach((column) => {
+                    if (!column.isInput) {
+                        prompt += `${column.displayName} ${row.columnBindings[column.columnId]}\n`;
+                    }
+                });
+            }
+        });
+        // Add the input column prompts
+        dataPrompt?.columns.forEach((column) => {
+            if (column.isInput) {
+                prompt += `${column.displayName} {${column.displayName.replace(":", "")}}\n`;
+            }
+        });
+        // Add just the first output column
+        const firstOutput = dataPrompt?.columns.find((column) => !column.isInput);
+        prompt += `${firstOutput?.displayName} `;
+        return prompt;
+    }
+    _promptValueChat() {
+        return (this.promptData?.multiturnPrompt
+            ?.preamble ?? "");
+    }
+    _promptValue() {
+        switch (this.promptType) {
+            case "text":
+                return this._promptValueText();
+            case "data":
+                return this._promptValueData();
+            case "chat":
+                return this._promptValueChat();
+            default:
+                throw new Error(`Invalid promptType: ${this.promptType}`);
+        }
+    }
+    /**
+     * Create a template from the prompt, including any "test input" specified
+     * in MakerSuite as a template parameter.
+     */
+    toTemplate() {
+        const value = this._promptValue();
+        const promptString = value.replaceAll(/{{.*:(.+):.*}}/g, "{$1}");
+        return index_js_1.PromptTemplate.fromTemplate(promptString);
+    }
+    _modelName() {
+        let ret = this.promptData?.runSettings?.model;
+        if (!ret) {
+            ret =
+                this.promptType === "chat"
+                    ? "models/chat-bison-001"
+                    : "models/text-bison-001";
+        }
+        return ret;
+    }
+    _examples() {
+        const promptData = this
+            .promptData;
+        const ret = promptData?.multiturnPrompt?.primingExchanges
+            .map((exchange) => {
+            const example = {};
+            if (exchange?.request) {
+                example.input = {
+                    content: exchange.request,
+                };
+            }
+            if (exchange?.response) {
+                example.output = {
+                    content: exchange.response,
+                };
+            }
+            return example;
+        })
+            .filter((value) => Object.keys(value).length);
+        return ret;
+    }
+    /**
+     * Create a model from the prompt with all the parameters (model name,
+     * temperature, etc) set as they were in MakerSuite.
+     */
+    toModel() {
+        const modelName = this._modelName();
+        const modelSettings = {
+            modelName,
+            ...this.promptData?.runSettings,
+        };
+        if (this.promptType === "chat") {
+            const examples = this._examples();
+            return new googlepalm_js_2.ChatGooglePaLM({
+                examples,
+                ...modelSettings,
+            });
+        }
+        else {
+            return new googlepalm_js_1.GooglePaLM(modelSettings);
+        }
+    }
+    /**
+     * Create a RunnableSequence based on the template and model that can
+     * be created from this prompt. The template will have parameters available
+     * based on the "test input" that was set in MakerSuite, and the model
+     * will have the parameters (model name, temperature, etc) from those in
+     * MakerSuite.
+     */
+    toChain() {
+        return this.toTemplate().pipe(this.toModel());
+    }
+}
+exports.MakerSuitePrompt = MakerSuitePrompt;
+class DriveFileReadConnection extends googlevertexai_connection_js_1.GoogleConnection {
+    constructor(fields, caller) {
+        super(caller, new google_auth_library_1.GoogleAuth({
+            scopes: "https://www.googleapis.com/auth/drive.readonly",
+            ...fields.authOptions,
+        }));
+        Object.defineProperty(this, "endpoint", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "apiVersion", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fileId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.endpoint = fields.endpoint ?? "www.googleapis.com";
+        this.apiVersion = fields.apiVersion ?? "v3";
+        this.fileId = fields.fileId;
+    }
+    async buildUrl() {
+        return `https://${this.endpoint}/drive/${this.apiVersion}/files/${this.fileId}?alt=media`;
+    }
+    buildMethod() {
+        return "GET";
+    }
+    async request(options) {
+        return this._request(undefined, options ?? {});
+    }
+}
+exports.DriveFileReadConnection = DriveFileReadConnection;
+/**
+ * A class allowing access to MakerSuite prompts that have been saved in
+ * Google Drive.
+ * MakerSuite prompts are pulled based on their Google Drive ID (which is available
+ * from Google Drive or as part of the URL when the prompt is open in MakerSuite).
+ * There is a basic cache that will store the prompt in memory for a time specified
+ * in milliseconds. This defaults to 0, indicating the prompt should always be
+ * pulled from Google Drive.
+ */
+class MakerSuiteHub {
+    constructor(config) {
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "cacheTimeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "caller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.cacheTimeout = config?.cacheTimeout ?? 0;
+        this.caller = config?.caller ?? new async_caller_js_1.AsyncCaller({});
+    }
+    /**
+     * Is the current cache entry valid, or does it need to be refreshed.
+     * It will need to be refreshed under any of the following conditions:
+     * - It does not currently exist in the cache
+     * - The cacheTimeout is 0
+     * - The cache was last updated longer ago than the cacheTimeout allows
+     * @param entry - The cache entry, including when this prompt was last refreshed
+     */
+    isValid(entry) {
+        // If we don't have a record, it can't be valid
+        // And if the cache timeout is 0, we will always refresh, so the cache is invalid
+        if (!entry || this.cacheTimeout === 0) {
+            return false;
+        }
+        const now = Date.now();
+        const expiration = entry.updated + this.cacheTimeout;
+        return expiration > now;
+    }
+    /**
+     * Get a MakerSuitePrompt that is specified by the Google Drive ID.
+     * This will always be loaded from Google Drive.
+     * @param id
+     * @return A MakerSuitePrompt which can be used to create a template, model, or chain.
+     */
+    async forcePull(id) {
+        const fields = {
+            fileId: id,
+        };
+        const connection = new DriveFileReadConnection(fields, this.caller);
+        const result = await connection.request();
+        const ret = new MakerSuitePrompt(result.data);
+        this.cache[id] = {
+            prompt: ret,
+            updated: Date.now(),
+        };
+        return ret;
+    }
+    /**
+     * Get a MakerSuitePrompt that is specified by the Google Drive ID. This may be
+     * loaded from Google Drive or, if there is a valid copy in the cache, the cached
+     * copy will be returned.
+     * @param id
+     * @return A MakerSuitePrompt which can be used to create a template, model, or chain.
+     */
+    async pull(id) {
+        const entry = this.cache[id];
+        const ret = this.isValid(entry) ? entry.prompt : await this.forcePull(id);
+        return ret;
+    }
+}
+exports.MakerSuiteHub = MakerSuiteHub;

package/dist/experimental/hubs/makersuite/googlemakersuitehub.d.ts

@@ -0,0 +1,183 @@
+import type { protos } from "@google-ai/generativelanguage";
+import type { google } from "@google-ai/generativelanguage/build/protos/protos.js";
+import { GoogleAuthOptions } from "google-auth-library";
+import { PromptTemplate } from "../../../prompts/index.js";
+import { BaseLanguageModel } from "../../../base_language/index.js";
+import { AsyncCaller, AsyncCallerCallOptions } from "../../../util/async_caller.js";
+import { GoogleResponse, GoogleVertexAIConnectionParams } from "../../../types/googlevertexai-types.js";
+import { GoogleConnection } from "../../../util/googlevertexai-connection.js";
+/**
+ * Configuration that allows us to load or pull a prompt that has been created
+ * by the Google MakerSuite site and saved in Google Drive.
+ *
+ * There is a simple in-memory cache of these prompts that is refreshed
+ * after the cacheTimeout specified in the configuration.
+ */
+export interface MakerSuiteHubConfig {
+    /**
+     * How long, in milliseconds, before a prompt is assumed stale and should
+     * be refreshed from the copy in Google Drive.
+     */
+    cacheTimeout: number;
+    caller?: AsyncCaller;
+}
+type MakerSuitePromptType = "text" | "data" | "chat";
+export interface MakerSuitePromptVariable {
+    variableId: string;
+    displayName: string;
+}
+export interface MakerSuiteRunSettings {
+    temperature?: number;
+    model: string;
+    candidateCount?: number;
+    topP?: number;
+    topK?: number;
+    maxOutputTokens: number;
+    safetySettings?: protos.google.ai.generativelanguage.v1beta2.ISafetySetting[];
+}
+export interface MakerSuiteTextPromptData {
+    textPrompt: {
+        value?: string;
+        variables?: MakerSuitePromptVariable[];
+    };
+    runSettings?: MakerSuiteRunSettings;
+    testExamples?: unknown;
+}
+export interface MakerSuiteDataPromptColumn {
+    columnId: string;
+    displayName: string;
+    isInput?: boolean;
+}
+export interface MakerSuiteDataPromptRow {
+    rowId: string;
+    columnBindings: Record<string, string>;
+}
+export interface MakerSuiteDataPromptData {
+    dataPrompt: {
+        preamble: string;
+        columns: MakerSuiteDataPromptColumn[];
+        rows: MakerSuiteDataPromptRow[];
+        rowsUsed: string[];
+    };
+    runSettings?: MakerSuiteRunSettings;
+    testExamples?: unknown;
+}
+export interface MakerSuiteChatExchange {
+    request?: string;
+    response?: string;
+    source: string;
+    id: string;
+}
+export interface MakerSuiteChatPromptData {
+    multiturnPrompt: {
+        preamble: string;
+        primingExchanges: MakerSuiteChatExchange[];
+        sessions: {
+            sessionExchanges: MakerSuiteChatExchange[];
+        }[];
+    };
+    runSettings?: MakerSuiteRunSettings;
+}
+/**
+ * These are the possible formats that the JSON generated by MakerSuite
+ * and saved in Google Drive can be.
+ */
+export type MakerSuitePromptData = MakerSuiteTextPromptData | MakerSuiteDataPromptData | MakerSuiteChatPromptData;
+/**
+ * A class that represents the Prompt that has been created by MakerSuite
+ * and loaded from Google Drive. It exposes methods to turn this prompt
+ * into a Template, a Model, and into a chain consisting of these two elements.
+ * In general, this class should be created by the MakerSuiteHub class and
+ * not instantiated manually.
+ */
+export declare class MakerSuitePrompt {
+    promptType: MakerSuitePromptType;
+    promptData: MakerSuitePromptData;
+    constructor(promptData: MakerSuitePromptData);
+    _determinePromptType(): void;
+    _promptValueText(): string;
+    _promptValueData(): string;
+    _promptValueChat(): string;
+    _promptValue(): string;
+    /**
+     * Create a template from the prompt, including any "test input" specified
+     * in MakerSuite as a template parameter.
+     */
+    toTemplate(): PromptTemplate;
+    _modelName(): string;
+    _examples(): google.ai.generativelanguage.v1beta2.IExample[];
+    /**
+     * Create a model from the prompt with all the parameters (model name,
+     * temperature, etc) set as they were in MakerSuite.
+     */
+    toModel(): BaseLanguageModel;
+    /**
+     * Create a RunnableSequence based on the template and model that can
+     * be created from this prompt. The template will have parameters available
+     * based on the "test input" that was set in MakerSuite, and the model
+     * will have the parameters (model name, temperature, etc) from those in
+     * MakerSuite.
+     */
+    toChain(): import("../../../schema/runnable/base.js").RunnableSequence<any, any>;
+}
+interface DriveFileReadParams extends GoogleVertexAIConnectionParams<GoogleAuthOptions> {
+    fileId: string;
+}
+interface DriveCallOptions extends AsyncCallerCallOptions {
+}
+interface DriveFileMakerSuiteResponse extends GoogleResponse {
+    data: MakerSuitePromptData;
+}
+export declare class DriveFileReadConnection extends GoogleConnection<DriveCallOptions, DriveFileMakerSuiteResponse> implements DriveFileReadParams {
+    endpoint: string;
+    apiVersion: string;
+    fileId: string;
+    constructor(fields: DriveFileReadParams, caller: AsyncCaller);
+    buildUrl(): Promise<string>;
+    buildMethod(): string;
+    request(options?: DriveCallOptions): Promise<DriveFileMakerSuiteResponse>;
+}
+export interface CacheEntry {
+    updated: number;
+    prompt: MakerSuitePrompt;
+}
+/**
+ * A class allowing access to MakerSuite prompts that have been saved in
+ * Google Drive.
+ * MakerSuite prompts are pulled based on their Google Drive ID (which is available
+ * from Google Drive or as part of the URL when the prompt is open in MakerSuite).
+ * There is a basic cache that will store the prompt in memory for a time specified
+ * in milliseconds. This defaults to 0, indicating the prompt should always be
+ * pulled from Google Drive.
+ */
+export declare class MakerSuiteHub {
+    cache: Record<string, CacheEntry>;
+    cacheTimeout: number;
+    caller: AsyncCaller;
+    constructor(config?: MakerSuiteHubConfig);
+    /**
+     * Is the current cache entry valid, or does it need to be refreshed.
+     * It will need to be refreshed under any of the following conditions:
+     * - It does not currently exist in the cache
+     * - The cacheTimeout is 0
+     * - The cache was last updated longer ago than the cacheTimeout allows
+     * @param entry - The cache entry, including when this prompt was last refreshed
+     */
+    isValid(entry: CacheEntry): boolean;
+    /**
+     * Get a MakerSuitePrompt that is specified by the Google Drive ID.
+     * This will always be loaded from Google Drive.
+     * @param id
+     * @return A MakerSuitePrompt which can be used to create a template, model, or chain.
+     */
+    forcePull(id: string): Promise<MakerSuitePrompt>;
+    /**
+     * Get a MakerSuitePrompt that is specified by the Google Drive ID. This may be
+     * loaded from Google Drive or, if there is a valid copy in the cache, the cached
+     * copy will be returned.
+     * @param id
+     * @return A MakerSuitePrompt which can be used to create a template, model, or chain.
+     */
+    pull(id: string): Promise<MakerSuitePrompt>;
+}
+export {};