@langchain/google-genai 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2023 LangChain
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/chat_models.cjs

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatGoogleGenerativeAI = void 0;
+const generative_ai_1 = require("@google/generative-ai");
+const env_1 = require("@langchain/core/utils/env");
+const chat_models_1 = require("@langchain/core/language_models/chat_models");
+const utils_js_1 = require("./utils.cjs");
+/**
+ * A class that wraps the Google Palm chat model.
+ * @example
+ * ```typescript
+ * const model = new ChatGoogleGenerativeAI({
+ *   apiKey: "<YOUR API KEY>",
+ *   temperature: 0.7,
+ *   modelName: "gemini-pro",
+ *   topK: 40,
+ *   topP: 1,
+ * });
+ * const questions = [
+ *   new HumanMessage({
+ *     content: [
+ *       {
+ *         type: "text",
+ *         text: "You are a funny assistant that answers in pirate language.",
+ *       },
+ *       {
+ *         type: "text",
+ *         text: "What is your favorite food?",
+ *       },
+ *     ]
+ *   })
+ * ];
+ * const res = await model.call(questions);
+ * console.log({ res });
+ * ```
+ */
+class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
+    static lc_name() {
+        return "googlegenerativeai";
+    }
+    get lc_secrets() {
+        return {
+            apiKey: "GOOGLE_API_KEY",
+        };
+    }
+    get _isMultimodalModel() {
+        return this.modelName.includes("vision");
+    }
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "gemini-pro"
+        });
+        Object.defineProperty(this, "temperature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // default value chosen based on model
+        Object.defineProperty(this, "maxOutputTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "topP", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // default value chosen based on model
+        Object.defineProperty(this, "topK", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // default value chosen based on model
+        Object.defineProperty(this, "stopSequences", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "safetySettings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "apiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.modelName =
+            fields?.modelName?.replace(/^models\//, "") ?? this.modelName;
+        this.maxOutputTokens = fields?.maxOutputTokens ?? this.maxOutputTokens;
+        if (this.maxOutputTokens && this.maxOutputTokens < 0) {
+            throw new Error("`maxOutputTokens` must be a positive integer");
+        }
+        this.temperature = fields?.temperature ?? this.temperature;
+        if (this.temperature && (this.temperature < 0 || this.temperature > 1)) {
+            throw new Error("`temperature` must be in the range of [0.0,1.0]");
+        }
+        this.topP = fields?.topP ?? this.topP;
+        if (this.topP && this.topP < 0) {
+            throw new Error("`topP` must be a positive integer");
+        }
+        if (this.topP && this.topP > 1) {
+            throw new Error("`topP` must be below 1.");
+        }
+        this.topK = fields?.topK ?? this.topK;
+        if (this.topK && this.topK < 0) {
+            throw new Error("`topK` must be a positive integer");
+        }
+        this.apiKey = fields?.apiKey ?? (0, env_1.getEnvironmentVariable)("GOOGLE_API_KEY");
+        if (!this.apiKey) {
+            throw new Error("Please set an API key for Google GenerativeAI " +
+                "in the environment variable GOOGLE_API_KEY " +
+                "or in the `apiKey` field of the " +
+                "ChatGoogleGenerativeAI constructor");
+        }
+        this.safetySettings = fields?.safetySettings ?? this.safetySettings;
+        if (this.safetySettings && this.safetySettings.length > 0) {
+            const safetySettingsSet = new Set(this.safetySettings.map((s) => s.category));
+            if (safetySettingsSet.size !== this.safetySettings.length) {
+                throw new Error("The categories in `safetySettings` array must be unique");
+            }
+        }
+        this.client = new generative_ai_1.GoogleGenerativeAI(this.apiKey).getGenerativeModel({
+            model: this.modelName,
+            safetySettings: this.safetySettings,
+            generationConfig: {
+                candidateCount: 1,
+                stopSequences: this.stopSequences,
+                maxOutputTokens: this.maxOutputTokens,
+                temperature: this.temperature,
+                topP: this.topP,
+                topK: this.topK,
+            },
+        });
+    }
+    _combineLLMOutput() {
+        return [];
+    }
+    _llmType() {
+        return "googlegenerativeai";
+    }
+    async _generate(messages, options, _runManager) {
+        const prompt = (0, utils_js_1.convertBaseMessagesToContent)(messages, this._isMultimodalModel);
+        const res = await this.caller.callWithOptions({ signal: options?.signal }, async () => {
+            let output;
+            try {
+                output = await this.client.generateContent({
+                    contents: prompt,
+                });
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (e) {
+                // TODO: Improve error handling
+                if (e.message?.includes("400 Bad Request")) {
+                    e.status = 400;
+                }
+                throw e;
+            }
+            return output;
+        });
+        return (0, utils_js_1.mapGenerateContentResultToChatResult)(res.response);
+    }
+    async *_streamResponseChunks(messages, options, _runManager) {
+        const prompt = (0, utils_js_1.convertBaseMessagesToContent)(messages, this._isMultimodalModel);
+        const stream = await this.caller.callWithOptions({ signal: options?.signal }, async () => {
+            const { stream } = await this.client.generateContentStream({
+                contents: prompt,
+            });
+            return stream;
+        });
+        for await (const response of stream) {
+            const chunk = (0, utils_js_1.convertResponseContentToChatGenerationChunk)(response);
+            if (!chunk) {
+                continue;
+            }
+            yield chunk;
+        }
+    }
+}
+exports.ChatGoogleGenerativeAI = ChatGoogleGenerativeAI;

package/dist/chat_models.d.ts

@@ -0,0 +1,130 @@
+import type { SafetySetting } from "@google/generative-ai";
+import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
+import { BaseMessage } from "@langchain/core/messages";
+import { ChatGenerationChunk, ChatResult } from "@langchain/core/outputs";
+import { BaseChatModel, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
+export type BaseMessageExamplePair = {
+    input: BaseMessage;
+    output: BaseMessage;
+};
+/**
+ * An interface defining the input to the ChatGoogleGenerativeAI class.
+ */
+export interface GoogleGenerativeAIChatInput extends BaseChatModelParams {
+    /**
+     * Model Name to use
+     *
+     * Note: The format must follow the pattern - `{model}`
+     */
+    modelName?: string;
+    /**
+     * Controls the randomness of the output.
+     *
+     * Values can range from [0.0,1.0], inclusive. A value closer to 1.0
+     * will produce responses that are more varied and creative, while
+     * a value closer to 0.0 will typically result in less surprising
+     * responses from the model.
+     *
+     * Note: The default value varies by model
+     */
+    temperature?: number;
+    /**
+     * Maximum number of tokens to generate in the completion.
+     */
+    maxOutputTokens?: number;
+    /**
+     * Top-p changes how the model selects tokens for output.
+     *
+     * Tokens are selected from most probable to least until the sum
+     * of their probabilities equals the top-p value.
+     *
+     * For example, if tokens A, B, and C have a probability of
+     * .3, .2, and .1 and the top-p value is .5, then the model will
+     * select either A or B as the next token (using temperature).
+     *
+     * Note: The default value varies by model
+     */
+    topP?: number;
+    /**
+     * Top-k changes how the model selects tokens for output.
+     *
+     * A top-k of 1 means the selected token is the most probable among
+     * all tokens in the model’s vocabulary (also called greedy decoding),
+     * while a top-k of 3 means that the next token is selected from
+     * among the 3 most probable tokens (using temperature).
+     *
+     * Note: The default value varies by model
+     */
+    topK?: number;
+    /**
+     * The set of character sequences (up to 5) that will stop output generation.
+     * If specified, the API will stop at the first appearance of a stop
+     * sequence.
+     *
+     * Note: The stop sequence will not be included as part of the response.
+     * Note: stopSequences is only supported for Gemini models
+     */
+    stopSequences?: string[];
+    /**
+     * A list of unique `SafetySetting` instances for blocking unsafe content. The API will block
+     * any prompts and responses that fail to meet the thresholds set by these settings. If there
+     * is no `SafetySetting` for a given `SafetyCategory` provided in the list, the API will use
+     * the default safety setting for that category.
+     */
+    safetySettings?: SafetySetting[];
+    /**
+     * Google API key to use
+     */
+    apiKey?: string;
+}
+/**
+ * A class that wraps the Google Palm chat model.
+ * @example
+ * ```typescript
+ * const model = new ChatGoogleGenerativeAI({
+ *   apiKey: "<YOUR API KEY>",
+ *   temperature: 0.7,
+ *   modelName: "gemini-pro",
+ *   topK: 40,
+ *   topP: 1,
+ * });
+ * const questions = [
+ *   new HumanMessage({
+ *     content: [
+ *       {
+ *         type: "text",
+ *         text: "You are a funny assistant that answers in pirate language.",
+ *       },
+ *       {
+ *         type: "text",
+ *         text: "What is your favorite food?",
+ *       },
+ *     ]
+ *   })
+ * ];
+ * const res = await model.call(questions);
+ * console.log({ res });
+ * ```
+ */
+export declare class ChatGoogleGenerativeAI extends BaseChatModel implements GoogleGenerativeAIChatInput {
+    static lc_name(): string;
+    lc_serializable: boolean;
+    get lc_secrets(): {
+        [key: string]: string;
+    } | undefined;
+    modelName: string;
+    temperature?: number;
+    maxOutputTokens?: number;
+    topP?: number;
+    topK?: number;
+    stopSequences: string[];
+    safetySettings?: SafetySetting[];
+    apiKey?: string;
+    private client;
+    get _isMultimodalModel(): boolean;
+    constructor(fields?: GoogleGenerativeAIChatInput);
+    _combineLLMOutput(): never[];
+    _llmType(): string;
+    _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+}

package/dist/chat_models.js

@@ -0,0 +1,199 @@
+import { GoogleGenerativeAI as GenerativeAI, } from "@google/generative-ai";
+import { getEnvironmentVariable } from "@langchain/core/utils/env";
+import { BaseChatModel, } from "@langchain/core/language_models/chat_models";
+import { convertBaseMessagesToContent, convertResponseContentToChatGenerationChunk, mapGenerateContentResultToChatResult, } from "./utils.js";
+/**
+ * A class that wraps the Google Palm chat model.
+ * @example
+ * ```typescript
+ * const model = new ChatGoogleGenerativeAI({
+ *   apiKey: "<YOUR API KEY>",
+ *   temperature: 0.7,
+ *   modelName: "gemini-pro",
+ *   topK: 40,
+ *   topP: 1,
+ * });
+ * const questions = [
+ *   new HumanMessage({
+ *     content: [
+ *       {
+ *         type: "text",
+ *         text: "You are a funny assistant that answers in pirate language.",
+ *       },
+ *       {
+ *         type: "text",
+ *         text: "What is your favorite food?",
+ *       },
+ *     ]
+ *   })
+ * ];
+ * const res = await model.call(questions);
+ * console.log({ res });
+ * ```
+ */
+export class ChatGoogleGenerativeAI extends BaseChatModel {
+    static lc_name() {
+        return "googlegenerativeai";
+    }
+    get lc_secrets() {
+        return {
+            apiKey: "GOOGLE_API_KEY",
+        };
+    }
+    get _isMultimodalModel() {
+        return this.modelName.includes("vision");
+    }
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "gemini-pro"
+        });
+        Object.defineProperty(this, "temperature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // default value chosen based on model
+        Object.defineProperty(this, "maxOutputTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "topP", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // default value chosen based on model
+        Object.defineProperty(this, "topK", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // default value chosen based on model
+        Object.defineProperty(this, "stopSequences", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "safetySettings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "apiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.modelName =
+            fields?.modelName?.replace(/^models\//, "") ?? this.modelName;
+        this.maxOutputTokens = fields?.maxOutputTokens ?? this.maxOutputTokens;
+        if (this.maxOutputTokens && this.maxOutputTokens < 0) {
+            throw new Error("`maxOutputTokens` must be a positive integer");
+        }
+        this.temperature = fields?.temperature ?? this.temperature;
+        if (this.temperature && (this.temperature < 0 || this.temperature > 1)) {
+            throw new Error("`temperature` must be in the range of [0.0,1.0]");
+        }
+        this.topP = fields?.topP ?? this.topP;
+        if (this.topP && this.topP < 0) {
+            throw new Error("`topP` must be a positive integer");
+        }
+        if (this.topP && this.topP > 1) {
+            throw new Error("`topP` must be below 1.");
+        }
+        this.topK = fields?.topK ?? this.topK;
+        if (this.topK && this.topK < 0) {
+            throw new Error("`topK` must be a positive integer");
+        }
+        this.apiKey = fields?.apiKey ?? getEnvironmentVariable("GOOGLE_API_KEY");
+        if (!this.apiKey) {
+            throw new Error("Please set an API key for Google GenerativeAI " +
+                "in the environment variable GOOGLE_API_KEY " +
+                "or in the `apiKey` field of the " +
+                "ChatGoogleGenerativeAI constructor");
+        }
+        this.safetySettings = fields?.safetySettings ?? this.safetySettings;
+        if (this.safetySettings && this.safetySettings.length > 0) {
+            const safetySettingsSet = new Set(this.safetySettings.map((s) => s.category));
+            if (safetySettingsSet.size !== this.safetySettings.length) {
+                throw new Error("The categories in `safetySettings` array must be unique");
+            }
+        }
+        this.client = new GenerativeAI(this.apiKey).getGenerativeModel({
+            model: this.modelName,
+            safetySettings: this.safetySettings,
+            generationConfig: {
+                candidateCount: 1,
+                stopSequences: this.stopSequences,
+                maxOutputTokens: this.maxOutputTokens,
+                temperature: this.temperature,
+                topP: this.topP,
+                topK: this.topK,
+            },
+        });
+    }
+    _combineLLMOutput() {
+        return [];
+    }
+    _llmType() {
+        return "googlegenerativeai";
+    }
+    async _generate(messages, options, _runManager) {
+        const prompt = convertBaseMessagesToContent(messages, this._isMultimodalModel);
+        const res = await this.caller.callWithOptions({ signal: options?.signal }, async () => {
+            let output;
+            try {
+                output = await this.client.generateContent({
+                    contents: prompt,
+                });
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (e) {
+                // TODO: Improve error handling
+                if (e.message?.includes("400 Bad Request")) {
+                    e.status = 400;
+                }
+                throw e;
+            }
+            return output;
+        });
+        return mapGenerateContentResultToChatResult(res.response);
+    }
+    async *_streamResponseChunks(messages, options, _runManager) {
+        const prompt = convertBaseMessagesToContent(messages, this._isMultimodalModel);
+        const stream = await this.caller.callWithOptions({ signal: options?.signal }, async () => {
+            const { stream } = await this.client.generateContentStream({
+                contents: prompt,
+            });
+            return stream;
+        });
+        for await (const response of stream) {
+            const chunk = convertResponseContentToChatGenerationChunk(response);
+            if (!chunk) {
+                continue;
+            }
+            yield chunk;
+        }
+    }
+}

package/dist/embeddings.cjs

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleGenerativeAIEmbeddings = void 0;
+const generative_ai_1 = require("@google/generative-ai");
+const env_1 = require("@langchain/core/utils/env");
+const embeddings_1 = require("@langchain/core/embeddings");
+/**
+ * Class that extends the Embeddings class and provides methods for
+ * generating embeddings using the Google Palm API.
+ * @example
+ * ```typescript
+ * const model = new GoogleGenerativeAIEmbeddings({
+ *   apiKey: "<YOUR API KEY>",
+ *   modelName: "embedding-001",
+ * });
+ *
+ * // Embed a single query
+ * const res = await model.embedQuery(
+ *   "What would be a good company name for a company that makes colorful socks?"
+ * );
+ * console.log({ res });
+ *
+ * // Embed multiple documents
+ * const documentRes = await model.embedDocuments(["Hello world", "Bye bye"]);
+ * console.log({ documentRes });
+ * ```
+ */
+class GoogleGenerativeAIEmbeddings extends embeddings_1.Embeddings {
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "apiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "embedding-001"
+        });
+        Object.defineProperty(this, "taskType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "title", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stripNewLines", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.modelName =
+            fields?.modelName?.replace(/^models\//, "") ?? this.modelName;
+        this.taskType = fields?.taskType ?? this.taskType;
+        this.title = fields?.title ?? this.title;
+        if (this.title && this.taskType !== "RETRIEVAL_DOCUMENT") {
+            throw new Error("title can only be sepcified with TaskType.RETRIEVAL_DOCUMENT");
+        }
+        this.apiKey = fields?.apiKey ?? (0, env_1.getEnvironmentVariable)("GOOGLE_API_KEY");
+        if (!this.apiKey) {
+            throw new Error("Please set an API key for Google GenerativeAI " +
+                "in the environmentb variable GOOGLE_API_KEY " +
+                "or in the `apiKey` field of the " +
+                "GoogleGenerativeAIEmbeddings constructor");
+        }
+        this.client = new generative_ai_1.GoogleGenerativeAI(this.apiKey).getGenerativeModel({
+            model: this.modelName,
+        });
+    }
+    _convertToContent(text) {
+        const cleanedText = this.stripNewLines ? text.replace(/\n/g, " ") : text;
+        return {
+            content: { role: "user", parts: [{ text: cleanedText }] },
+            taskType: this.taskType,
+            title: this.title,
+        };
+    }
+    async _embedQueryContent(text) {
+        const req = this._convertToContent(text);
+        const res = await this.client.embedContent(req);
+        return res.embedding.values ?? [];
+    }
+    async _embedDocumentsContent(documents) {
+        const req = {
+            requests: documents.map((doc) => this._convertToContent(doc)),
+        };
+        const res = await this.client.batchEmbedContents(req);
+        return res.embeddings.map((e) => e.values || []) ?? [];
+    }
+    /**
+     * 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.call(this._embedQueryContent.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 this.caller.call(this._embedDocumentsContent.bind(this), documents);
+    }
+}
+exports.GoogleGenerativeAIEmbeddings = GoogleGenerativeAIEmbeddings;

package/dist/embeddings.d.ts

@@ -0,0 +1,84 @@
+import type { TaskType } from "@google/generative-ai";
+import { Embeddings, EmbeddingsParams } from "@langchain/core/embeddings";
+/**
+ * Interface that extends EmbeddingsParams and defines additional
+ * parameters specific to the GoogleGenerativeAIEmbeddings class.
+ */
+export interface GoogleGenerativeAIEmbeddingsParams extends EmbeddingsParams {
+    /**
+     * Model Name to use
+     *
+     * Note: The format must follow the pattern - `{model}`
+     */
+    modelName?: string;
+    /**
+     * Type of task for which the embedding will be used
+     *
+     * Note: currently only supported by `embedding-001` model
+     */
+    taskType?: TaskType;
+    /**
+     * An optional title for the text. Only applicable when TaskType is
+     * `RETRIEVAL_DOCUMENT`
+     *
+     * Note: currently only supported by `embedding-001` model
+     */
+    title?: string;
+    /**
+     * Whether to strip new lines from the input text. Default to true
+     */
+    stripNewLines?: boolean;
+    /**
+     * Google API key to use
+     */
+    apiKey?: string;
+}
+/**
+ * Class that extends the Embeddings class and provides methods for
+ * generating embeddings using the Google Palm API.
+ * @example
+ * ```typescript
+ * const model = new GoogleGenerativeAIEmbeddings({
+ *   apiKey: "<YOUR API KEY>",
+ *   modelName: "embedding-001",
+ * });
+ *
+ * // Embed a single query
+ * const res = await model.embedQuery(
+ *   "What would be a good company name for a company that makes colorful socks?"
+ * );
+ * console.log({ res });
+ *
+ * // Embed multiple documents
+ * const documentRes = await model.embedDocuments(["Hello world", "Bye bye"]);
+ * console.log({ documentRes });
+ * ```
+ */
+export declare class GoogleGenerativeAIEmbeddings extends Embeddings implements GoogleGenerativeAIEmbeddingsParams {
+    apiKey?: string;
+    modelName: string;
+    taskType?: TaskType;
+    title?: string;
+    stripNewLines: boolean;
+    private client;
+    constructor(fields?: GoogleGenerativeAIEmbeddingsParams);
+    private _convertToContent;
+    protected _embedQueryContent(text: string): Promise<number[]>;
+    protected _embedDocumentsContent(documents: 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.js

@@ -0,0 +1,122 @@
+import { GoogleGenerativeAI } from "@google/generative-ai";
+import { getEnvironmentVariable } from "@langchain/core/utils/env";
+import { Embeddings } from "@langchain/core/embeddings";
+/**
+ * Class that extends the Embeddings class and provides methods for
+ * generating embeddings using the Google Palm API.
+ * @example
+ * ```typescript
+ * const model = new GoogleGenerativeAIEmbeddings({
+ *   apiKey: "<YOUR API KEY>",
+ *   modelName: "embedding-001",
+ * });
+ *
+ * // Embed a single query
+ * const res = await model.embedQuery(
+ *   "What would be a good company name for a company that makes colorful socks?"
+ * );
+ * console.log({ res });
+ *
+ * // Embed multiple documents
+ * const documentRes = await model.embedDocuments(["Hello world", "Bye bye"]);
+ * console.log({ documentRes });
+ * ```
+ */
+export class GoogleGenerativeAIEmbeddings extends Embeddings {
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "apiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "embedding-001"
+        });
+        Object.defineProperty(this, "taskType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "title", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stripNewLines", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.modelName =
+            fields?.modelName?.replace(/^models\//, "") ?? this.modelName;
+        this.taskType = fields?.taskType ?? this.taskType;
+        this.title = fields?.title ?? this.title;
+        if (this.title && this.taskType !== "RETRIEVAL_DOCUMENT") {
+            throw new Error("title can only be sepcified with TaskType.RETRIEVAL_DOCUMENT");
+        }
+        this.apiKey = fields?.apiKey ?? getEnvironmentVariable("GOOGLE_API_KEY");
+        if (!this.apiKey) {
+            throw new Error("Please set an API key for Google GenerativeAI " +
+                "in the environmentb variable GOOGLE_API_KEY " +
+                "or in the `apiKey` field of the " +
+                "GoogleGenerativeAIEmbeddings constructor");
+        }
+        this.client = new GoogleGenerativeAI(this.apiKey).getGenerativeModel({
+            model: this.modelName,
+        });
+    }
+    _convertToContent(text) {
+        const cleanedText = this.stripNewLines ? text.replace(/\n/g, " ") : text;
+        return {
+            content: { role: "user", parts: [{ text: cleanedText }] },
+            taskType: this.taskType,
+            title: this.title,
+        };
+    }
+    async _embedQueryContent(text) {
+        const req = this._convertToContent(text);
+        const res = await this.client.embedContent(req);
+        return res.embedding.values ?? [];
+    }
+    async _embedDocumentsContent(documents) {
+        const req = {
+            requests: documents.map((doc) => this._convertToContent(doc)),
+        };
+        const res = await this.client.batchEmbedContents(req);
+        return res.embeddings.map((e) => e.values || []) ?? [];
+    }
+    /**
+     * 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.call(this._embedQueryContent.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 this.caller.call(this._embedDocumentsContent.bind(this), documents);
+    }
+}

package/dist/index.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./chat_models.cjs"), exports);
+__exportStar(require("./embeddings.cjs"), exports);

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./chat_models.js";
+export * from "./embeddings.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./chat_models.js";
+export * from "./embeddings.js";

package/dist/utils.cjs

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertResponseContentToChatGenerationChunk = exports.mapGenerateContentResultToChatResult = exports.convertBaseMessagesToContent = exports.convertMessageContentToParts = exports.convertAuthorToRole = exports.getMessageAuthor = void 0;
+const messages_1 = require("@langchain/core/messages");
+const outputs_1 = require("@langchain/core/outputs");
+function getMessageAuthor(message) {
+    const type = message._getType();
+    if (messages_1.ChatMessage.isInstance(message)) {
+        return message.role;
+    }
+    return message.name ?? type;
+}
+exports.getMessageAuthor = getMessageAuthor;
+/**
+ * Maps a message type to a Google Generative AI chat author.
+ * @param message The message to map.
+ * @param model The model to use for mapping.
+ * @returns The message type mapped to a Google Generative AI chat author.
+ */
+function convertAuthorToRole(author) {
+    switch (author) {
+        /**
+         *  Note: Gemini currently is not supporting system messages
+         *  we will convert them to human messages and merge with following
+         * */
+        case "ai":
+            return "model";
+        case "system":
+        case "human":
+            return "user";
+        default:
+            throw new Error(`Unknown / unsupported author: ${author}`);
+    }
+}
+exports.convertAuthorToRole = convertAuthorToRole;
+function convertMessageContentToParts(content, isMultimodalModel) {
+    if (typeof content === "string") {
+        return [{ text: content }];
+    }
+    return content.map((c) => {
+        if (c.type === "text") {
+            return {
+                text: c.text,
+            };
+        }
+        if (c.type === "image_url") {
+            if (!isMultimodalModel) {
+                throw new Error(`This model does not support images`);
+            }
+            if (typeof c.image_url !== "string") {
+                throw new Error("Please provide image as base64 encoded data URL");
+            }
+            const [dm, data] = c.image_url.split(",");
+            if (!dm.startsWith("data:")) {
+                throw new Error("Please provide image as base64 encoded data URL");
+            }
+            const [mimeType, encoding] = dm.replace(/^data:/, "").split(";");
+            if (encoding !== "base64") {
+                throw new Error("Please provide image as base64 encoded data URL");
+            }
+            return {
+                inlineData: {
+                    data,
+                    mimeType,
+                },
+            };
+        }
+        throw new Error(`Unknown content type ${c.type}`);
+    });
+}
+exports.convertMessageContentToParts = convertMessageContentToParts;
+function convertBaseMessagesToContent(messages, isMultimodalModel) {
+    return messages.reduce((acc, message, index) => {
+        if (!(0, messages_1.isBaseMessage)(message)) {
+            throw new Error("Unsupported message input");
+        }
+        const author = getMessageAuthor(message);
+        if (author === "system" && index !== 0) {
+            throw new Error("System message should be the first one");
+        }
+        const role = convertAuthorToRole(author);
+        const prevContent = acc.content[acc.content.length];
+        if (!acc.mergeWithPreviousContent &&
+            prevContent &&
+            prevContent.role === role) {
+            throw new Error("Google Generative AI requires alternate messages between authors");
+        }
+        const parts = convertMessageContentToParts(message.content, isMultimodalModel);
+        if (acc.mergeWithPreviousContent) {
+            const prevContent = acc.content[acc.content.length - 1];
+            if (!prevContent) {
+                throw new Error("There was a problem parsing your system message. Please try a prompt without one.");
+            }
+            prevContent.parts.push(...parts);
+            return {
+                mergeWithPreviousContent: false,
+                content: acc.content,
+            };
+        }
+        const content = {
+            role,
+            parts,
+        };
+        return {
+            mergeWithPreviousContent: author === "system",
+            content: [...acc.content, content],
+        };
+    }, { content: [], mergeWithPreviousContent: false }).content;
+}
+exports.convertBaseMessagesToContent = convertBaseMessagesToContent;
+function mapGenerateContentResultToChatResult(response) {
+    // if rejected or error, return empty generations with reason in filters
+    if (!response.candidates ||
+        response.candidates.length === 0 ||
+        !response.candidates[0]) {
+        return {
+            generations: [],
+            llmOutput: {
+                filters: response.promptFeedback,
+            },
+        };
+    }
+    const [candidate] = response.candidates;
+    const { content, ...generationInfo } = candidate;
+    const text = content.parts[0]?.text ?? "";
+    const generation = {
+        text,
+        message: new messages_1.AIMessage({
+            content: text,
+            name: content === null ? undefined : content.role,
+            additional_kwargs: {},
+        }),
+        generationInfo,
+    };
+    return {
+        generations: [generation],
+    };
+}
+exports.mapGenerateContentResultToChatResult = mapGenerateContentResultToChatResult;
+function convertResponseContentToChatGenerationChunk(response) {
+    if (!response.candidates || response.candidates.length === 0) {
+        return null;
+    }
+    const [candidate] = response.candidates;
+    const { content, ...generationInfo } = candidate;
+    const text = content.parts[0]?.text ?? "";
+    return new outputs_1.ChatGenerationChunk({
+        text,
+        message: new messages_1.AIMessageChunk({
+            content: text,
+            name: content === null ? undefined : content.role,
+            additional_kwargs: {},
+        }),
+        generationInfo,
+    });
+}
+exports.convertResponseContentToChatGenerationChunk = convertResponseContentToChatGenerationChunk;

package/dist/utils.d.ts

@@ -0,0 +1,15 @@
+import { EnhancedGenerateContentResponse, Content, Part } from "@google/generative-ai";
+import { BaseMessage, MessageContent } from "@langchain/core/messages";
+import { ChatGenerationChunk, ChatResult } from "@langchain/core/outputs";
+export declare function getMessageAuthor(message: BaseMessage): string;
+/**
+ * Maps a message type to a Google Generative AI chat author.
+ * @param message The message to map.
+ * @param model The model to use for mapping.
+ * @returns The message type mapped to a Google Generative AI chat author.
+ */
+export declare function convertAuthorToRole(author: string): "model" | "user";
+export declare function convertMessageContentToParts(content: MessageContent, isMultimodalModel: boolean): Part[];
+export declare function convertBaseMessagesToContent(messages: BaseMessage[], isMultimodalModel: boolean): Content[];
+export declare function mapGenerateContentResultToChatResult(response: EnhancedGenerateContentResponse): ChatResult;
+export declare function convertResponseContentToChatGenerationChunk(response: EnhancedGenerateContentResponse): ChatGenerationChunk | null;

package/dist/utils.js

@@ -0,0 +1,148 @@
+import { AIMessage, AIMessageChunk, ChatMessage, isBaseMessage, } from "@langchain/core/messages";
+import { ChatGenerationChunk, } from "@langchain/core/outputs";
+export function getMessageAuthor(message) {
+    const type = message._getType();
+    if (ChatMessage.isInstance(message)) {
+        return message.role;
+    }
+    return message.name ?? type;
+}
+/**
+ * Maps a message type to a Google Generative AI chat author.
+ * @param message The message to map.
+ * @param model The model to use for mapping.
+ * @returns The message type mapped to a Google Generative AI chat author.
+ */
+export function convertAuthorToRole(author) {
+    switch (author) {
+        /**
+         *  Note: Gemini currently is not supporting system messages
+         *  we will convert them to human messages and merge with following
+         * */
+        case "ai":
+            return "model";
+        case "system":
+        case "human":
+            return "user";
+        default:
+            throw new Error(`Unknown / unsupported author: ${author}`);
+    }
+}
+export function convertMessageContentToParts(content, isMultimodalModel) {
+    if (typeof content === "string") {
+        return [{ text: content }];
+    }
+    return content.map((c) => {
+        if (c.type === "text") {
+            return {
+                text: c.text,
+            };
+        }
+        if (c.type === "image_url") {
+            if (!isMultimodalModel) {
+                throw new Error(`This model does not support images`);
+            }
+            if (typeof c.image_url !== "string") {
+                throw new Error("Please provide image as base64 encoded data URL");
+            }
+            const [dm, data] = c.image_url.split(",");
+            if (!dm.startsWith("data:")) {
+                throw new Error("Please provide image as base64 encoded data URL");
+            }
+            const [mimeType, encoding] = dm.replace(/^data:/, "").split(";");
+            if (encoding !== "base64") {
+                throw new Error("Please provide image as base64 encoded data URL");
+            }
+            return {
+                inlineData: {
+                    data,
+                    mimeType,
+                },
+            };
+        }
+        throw new Error(`Unknown content type ${c.type}`);
+    });
+}
+export function convertBaseMessagesToContent(messages, isMultimodalModel) {
+    return messages.reduce((acc, message, index) => {
+        if (!isBaseMessage(message)) {
+            throw new Error("Unsupported message input");
+        }
+        const author = getMessageAuthor(message);
+        if (author === "system" && index !== 0) {
+            throw new Error("System message should be the first one");
+        }
+        const role = convertAuthorToRole(author);
+        const prevContent = acc.content[acc.content.length];
+        if (!acc.mergeWithPreviousContent &&
+            prevContent &&
+            prevContent.role === role) {
+            throw new Error("Google Generative AI requires alternate messages between authors");
+        }
+        const parts = convertMessageContentToParts(message.content, isMultimodalModel);
+        if (acc.mergeWithPreviousContent) {
+            const prevContent = acc.content[acc.content.length - 1];
+            if (!prevContent) {
+                throw new Error("There was a problem parsing your system message. Please try a prompt without one.");
+            }
+            prevContent.parts.push(...parts);
+            return {
+                mergeWithPreviousContent: false,
+                content: acc.content,
+            };
+        }
+        const content = {
+            role,
+            parts,
+        };
+        return {
+            mergeWithPreviousContent: author === "system",
+            content: [...acc.content, content],
+        };
+    }, { content: [], mergeWithPreviousContent: false }).content;
+}
+export function mapGenerateContentResultToChatResult(response) {
+    // if rejected or error, return empty generations with reason in filters
+    if (!response.candidates ||
+        response.candidates.length === 0 ||
+        !response.candidates[0]) {
+        return {
+            generations: [],
+            llmOutput: {
+                filters: response.promptFeedback,
+            },
+        };
+    }
+    const [candidate] = response.candidates;
+    const { content, ...generationInfo } = candidate;
+    const text = content.parts[0]?.text ?? "";
+    const generation = {
+        text,
+        message: new AIMessage({
+            content: text,
+            name: content === null ? undefined : content.role,
+            additional_kwargs: {},
+        }),
+        generationInfo,
+    };
+    return {
+        generations: [generation],
+    };
+}
+export function convertResponseContentToChatGenerationChunk(response) {
+    if (!response.candidates || response.candidates.length === 0) {
+        return null;
+    }
+    const [candidate] = response.candidates;
+    const { content, ...generationInfo } = candidate;
+    const text = content.parts[0]?.text ?? "";
+    return new ChatGenerationChunk({
+        text,
+        message: new AIMessageChunk({
+            content: text,
+            name: content === null ? undefined : content.role,
+            additional_kwargs: {},
+        }),
+        generationInfo,
+    });
+}

package/index.cjs

@@ -0,0 +1 @@
+module.exports = require('./dist/index.cjs');

package/index.d.ts

@@ -0,0 +1 @@
+export * from './dist/index.js'

package/index.js

@@ -0,0 +1 @@
+export * from './dist/index.js'

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@langchain/google-genai",
+  "version": "0.0.1",
+  "description": "Sample integration for LangChain.js",
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:langchain-ai/langchainjs.git"
+  },
+  "scripts": {
+    "build": "yarn run build:deps && yarn clean && yarn build:esm && yarn build:cjs && yarn build:scripts",
+    "build:deps": "yarn run turbo:command build --filter=@langchain/core",
+    "build:esm": "NODE_OPTIONS=--max-old-space-size=4096 tsc --outDir dist/ && rm -rf dist/tests dist/**/tests",
+    "build:cjs": "NODE_OPTIONS=--max-old-space-size=4096 tsc --outDir dist-cjs/ -p tsconfig.cjs.json && node scripts/move-cjs-to-dist.js && rm -rf dist-cjs",
+    "build:watch": "node scripts/create-entrypoints.js && tsc --outDir dist/ --watch",
+    "build:scripts": "node scripts/create-entrypoints.js && node scripts/check-tree-shaking.js",
+    "lint": "NODE_OPTIONS=--max-old-space-size=4096 eslint src && dpdm --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts",
+    "lint:fix": "yarn lint --fix",
+    "clean": "rm -rf dist/ && NODE_OPTIONS=--max-old-space-size=4096 node scripts/create-entrypoints.js pre",
+    "prepack": "yarn build",
+    "release": "release-it --only-version --config .release-it.json",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --testPathIgnorePatterns=\\.int\\.test.ts --testTimeout 30000 --maxWorkers=50%",
+    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch --testPathIgnorePatterns=\\.int\\.test.ts",
+    "test:single": "NODE_OPTIONS=--experimental-vm-modules yarn run jest --config jest.config.cjs --testTimeout 100000",
+    "test:int": "NODE_OPTIONS=--experimental-vm-modules jest --testPathPattern=\\.int\\.test.ts --testTimeout 100000 --maxWorkers=50%",
+    "format": "prettier --write \"src\"",
+    "format:check": "prettier --check \"src\""
+  },
+  "author": "LangChain",
+  "license": "MIT",
+  "dependencies": {
+    "@google/generative-ai": "^0.1.0",
+    "@langchain/core": "~0.1.1"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@langchain/community": "workspace:*",
+    "@swc/core": "^1.3.90",
+    "@swc/jest": "^0.2.29",
+    "@tsconfig/recommended": "^1.0.3",
+    "@typescript-eslint/eslint-plugin": "^6.12.0",
+    "@typescript-eslint/parser": "^6.12.0",
+    "dotenv": "^16.3.1",
+    "dpdm": "^3.12.0",
+    "eslint": "^8.33.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-no-instanceof": "^1.0.1",
+    "eslint-plugin-prettier": "^4.2.1",
+    "hnswlib-node": "^1.4.2",
+    "jest": "^29.5.0",
+    "jest-environment-node": "^29.6.4",
+    "prettier": "^2.8.3",
+    "rollup": "^4.5.2",
+    "ts-jest": "^29.1.0",
+    "typescript": "<5.2.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/",
+    "index.cjs",
+    "index.js",
+    "index.d.ts"
+  ]
+}