@langchain/google-common 0.0.0

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/README.md

@@ -0,0 +1,47 @@
+# LangChain google-common
+
+This package contains common resources to access Google AI/ML models
+and other Google services in an auth-independent way.
+
+AI/ML models are supported using the same interface no matter if
+you are using the Google AI Studio-based version of the model or
+the Google Cloud Vertex AI version of the model.
+
+## Installation
+
+This is **not** a stand-alone package since it does not contain code to do
+authorization.
+
+Instead, you should install *one* of the following packages:
+* @langchain/google-gauth
+* @langchain/google-webauth
+
+See those packages for details about installation.
+
+This package does **not** depend on any Google library. Instead, it relies on
+REST calls to Google endpoints. This is deliberate to reduce (sometimes
+conflicting) dependencies and make it usable on platforms that do not include
+file storage.
+
+
+## Google services supported
+
+* Gemini model through LLM and Chat classes (both through Google AI Studio and 
+  Google Cloud Vertex AI)
+
+
+## TODO
+
+Tasks and services still to be implemented:
+
+* Functions for Gemini
+* PaLM Vertex AI support and backwards compatibility
+* PaLM MakerSuite support and backwards compatibility
+* Semantic Retrieval / AQA model
+* PaLM embeddings
+* Gemini embeddings
+* Multimodal embeddings
+* Vertex AI Search
+* Vertex AI Model Garden
+* MakerSuite / Google Drive Hub
+* Google Cloud Vector Store

package/dist/auth.cjs

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureAuthOptionScopes = exports.aiPlatformScope = exports.ApiKeyGoogleAuth = exports.GoogleAbstractedFetchClient = void 0;
+const stream_js_1 = require("./utils/stream.cjs");
+class GoogleAbstractedFetchClient {
+    async _request(url, opts, additionalHeaders) {
+        if (url == null)
+            throw new Error("Missing URL");
+        const fetchOptions = {
+            method: opts.method,
+            headers: {
+                "Content-Type": "application/json",
+                ...(opts.headers ?? {}),
+                ...(additionalHeaders ?? {}),
+            },
+        };
+        if (opts.data !== undefined) {
+            fetchOptions.body = JSON.stringify(opts.data);
+        }
+        const res = await fetch(url, fetchOptions);
+        if (!res.ok) {
+            const error = new Error(`Could not get access token for Google with status code: ${res.status}`);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            error.response = res;
+            throw error;
+        }
+        return {
+            data: opts.responseType === "json"
+                ? await res.json()
+                : new stream_js_1.ReadableJsonStream(res.body),
+            config: {},
+            status: res.status,
+            statusText: res.statusText,
+            headers: res.headers,
+            request: { responseURL: res.url },
+        };
+    }
+}
+exports.GoogleAbstractedFetchClient = GoogleAbstractedFetchClient;
+class ApiKeyGoogleAuth extends GoogleAbstractedFetchClient {
+    constructor(apiKey) {
+        super();
+        Object.defineProperty(this, "apiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.apiKey = apiKey;
+    }
+    get clientType() {
+        return "apiKey";
+    }
+    getProjectId() {
+        throw new Error("APIs that require a project ID cannot use an API key");
+        // Perhaps we could implement this if needed:
+        // https://cloud.google.com/docs/authentication/api-keys#get-info
+    }
+    request(opts) {
+        const authHeader = {
+            "X-Goog-Api-Key": this.apiKey,
+        };
+        return this._request(opts.url, opts, authHeader);
+    }
+}
+exports.ApiKeyGoogleAuth = ApiKeyGoogleAuth;
+function aiPlatformScope(platform) {
+    switch (platform) {
+        case "gai":
+            return ["https://www.googleapis.com/auth/generative-language"];
+        default:
+            return ["https://www.googleapis.com/auth/cloud-platform"];
+    }
+}
+exports.aiPlatformScope = aiPlatformScope;
+function ensureAuthOptionScopes(authOption, scopeProperty, scopesOrPlatform) {
+    // If the property is already set, return it
+    if (authOption && Object.hasOwn(authOption, scopeProperty)) {
+        return authOption;
+    }
+    // Otherwise add it
+    const scopes = Array.isArray(scopesOrPlatform)
+        ? scopesOrPlatform
+        : aiPlatformScope(scopesOrPlatform ?? "gcp");
+    return {
+        [scopeProperty]: scopes,
+        ...(authOption ?? {}),
+    };
+}
+exports.ensureAuthOptionScopes = ensureAuthOptionScopes;

package/dist/auth.d.ts

@@ -0,0 +1,39 @@
+import { GooglePlatformType } from "./types.js";
+export type GoogleAbstractedClientOpsMethod = "GET" | "POST";
+export type GoogleAbstractedClientOpsResponseType = "json" | "stream";
+export type GoogleAbstractedClientOps = {
+    url?: string;
+    method?: GoogleAbstractedClientOpsMethod;
+    headers?: Record<string, string>;
+    data?: unknown;
+    responseType?: GoogleAbstractedClientOpsResponseType;
+};
+export interface GoogleAbstractedClient {
+    request: (opts: GoogleAbstractedClientOps) => unknown;
+    getProjectId: () => Promise<string>;
+    get clientType(): string;
+}
+export declare abstract class GoogleAbstractedFetchClient implements GoogleAbstractedClient {
+    abstract get clientType(): string;
+    abstract getProjectId(): Promise<string>;
+    abstract request(opts: GoogleAbstractedClientOps): unknown;
+    _request(url: string | undefined, opts: GoogleAbstractedClientOps, additionalHeaders: Record<string, string>): Promise<{
+        data: any;
+        config: {};
+        status: number;
+        statusText: string;
+        headers: Headers;
+        request: {
+            responseURL: string;
+        };
+    }>;
+}
+export declare class ApiKeyGoogleAuth extends GoogleAbstractedFetchClient {
+    apiKey: string;
+    constructor(apiKey: string);
+    get clientType(): string;
+    getProjectId(): Promise<string>;
+    request(opts: GoogleAbstractedClientOps): unknown;
+}
+export declare function aiPlatformScope(platform: GooglePlatformType): string[];
+export declare function ensureAuthOptionScopes<AuthOptions>(authOption: AuthOptions | undefined, scopeProperty: string, scopesOrPlatform: string[] | GooglePlatformType | undefined): AuthOptions;

package/dist/auth.js

@@ -0,0 +1,83 @@
+import { ReadableJsonStream } from "./utils/stream.js";
+export class GoogleAbstractedFetchClient {
+    async _request(url, opts, additionalHeaders) {
+        if (url == null)
+            throw new Error("Missing URL");
+        const fetchOptions = {
+            method: opts.method,
+            headers: {
+                "Content-Type": "application/json",
+                ...(opts.headers ?? {}),
+                ...(additionalHeaders ?? {}),
+            },
+        };
+        if (opts.data !== undefined) {
+            fetchOptions.body = JSON.stringify(opts.data);
+        }
+        const res = await fetch(url, fetchOptions);
+        if (!res.ok) {
+            const error = new Error(`Could not get access token for Google with status code: ${res.status}`);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            error.response = res;
+            throw error;
+        }
+        return {
+            data: opts.responseType === "json"
+                ? await res.json()
+                : new ReadableJsonStream(res.body),
+            config: {},
+            status: res.status,
+            statusText: res.statusText,
+            headers: res.headers,
+            request: { responseURL: res.url },
+        };
+    }
+}
+export class ApiKeyGoogleAuth extends GoogleAbstractedFetchClient {
+    constructor(apiKey) {
+        super();
+        Object.defineProperty(this, "apiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.apiKey = apiKey;
+    }
+    get clientType() {
+        return "apiKey";
+    }
+    getProjectId() {
+        throw new Error("APIs that require a project ID cannot use an API key");
+        // Perhaps we could implement this if needed:
+        // https://cloud.google.com/docs/authentication/api-keys#get-info
+    }
+    request(opts) {
+        const authHeader = {
+            "X-Goog-Api-Key": this.apiKey,
+        };
+        return this._request(opts.url, opts, authHeader);
+    }
+}
+export function aiPlatformScope(platform) {
+    switch (platform) {
+        case "gai":
+            return ["https://www.googleapis.com/auth/generative-language"];
+        default:
+            return ["https://www.googleapis.com/auth/cloud-platform"];
+    }
+}
+export function ensureAuthOptionScopes(authOption, scopeProperty, scopesOrPlatform) {
+    // If the property is already set, return it
+    if (authOption && Object.hasOwn(authOption, scopeProperty)) {
+        return authOption;
+    }
+    // Otherwise add it
+    const scopes = Array.isArray(scopesOrPlatform)
+        ? scopesOrPlatform
+        : aiPlatformScope(scopesOrPlatform ?? "gcp");
+    return {
+        [scopeProperty]: scopes,
+        ...(authOption ?? {}),
+    };
+}

package/dist/chat_models.cjs

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatGoogleBase = void 0;
+const env_1 = require("@langchain/core/utils/env");
+const chat_models_1 = require("@langchain/core/language_models/chat_models");
+const outputs_1 = require("@langchain/core/outputs");
+const messages_1 = require("@langchain/core/messages");
+const common_js_1 = require("./utils/common.cjs");
+const connection_js_1 = require("./connection.cjs");
+const gemini_js_1 = require("./utils/gemini.cjs");
+const auth_js_1 = require("./auth.cjs");
+class ChatConnection extends connection_js_1.AbstractGoogleLLMConnection {
+    formatContents(input, _parameters) {
+        return input
+            .map((msg) => (0, gemini_js_1.baseMessageToContent)(msg))
+            .reduce((acc, cur) => [...acc, ...cur]);
+    }
+}
+/**
+ * Integration with a chat model.
+ */
+class ChatGoogleBase extends chat_models_1.BaseChatModel {
+    // Used for tracing, replace with the same name as your class
+    static lc_name() {
+        return "ChatGoogle";
+    }
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "gemini-pro"
+        });
+        Object.defineProperty(this, "temperature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0.7
+        });
+        Object.defineProperty(this, "maxOutputTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1024
+        });
+        Object.defineProperty(this, "topP", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0.8
+        });
+        Object.defineProperty(this, "topK", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 40
+        });
+        Object.defineProperty(this, "stopSequences", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "safetySettings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "connection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "streamedConnection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        (0, common_js_1.copyAndValidateModelParamsInto)(fields, this);
+        const client = this.buildClient(fields);
+        this.buildConnection(fields ?? {}, client);
+    }
+    buildApiKeyClient(apiKey) {
+        return new auth_js_1.ApiKeyGoogleAuth(apiKey);
+    }
+    buildApiKey(fields) {
+        return fields?.apiKey ?? (0, env_1.getEnvironmentVariable)("GOOGLE_API_KEY");
+    }
+    buildClient(fields) {
+        const apiKey = this.buildApiKey(fields);
+        if (apiKey) {
+            return this.buildApiKeyClient(apiKey);
+        }
+        else {
+            return this.buildAbstractedClient(fields);
+        }
+    }
+    buildConnection(fields, client) {
+        this.connection = new ChatConnection({ ...fields, ...this }, this.caller, client, false);
+        this.streamedConnection = new ChatConnection({ ...fields, ...this }, this.caller, client, true);
+    }
+    get platform() {
+        return this.connection.platform;
+    }
+    // Replace
+    _llmType() {
+        return "chat_integration";
+    }
+    async _generate(messages, options, _runManager) {
+        const parameters = (0, common_js_1.copyAIModelParams)(this);
+        const response = await this.connection.request(messages, parameters, options);
+        const ret = (0, gemini_js_1.responseToChatResult)(response);
+        return ret;
+    }
+    async *_streamResponseChunks(_messages, _options, _runManager) {
+        // Make the call as a streaming request
+        const parameters = (0, common_js_1.copyAIModelParams)(this);
+        const response = await this.streamedConnection.request(_messages, parameters, _options);
+        // Get the streaming parser of the response
+        const stream = response.data;
+        // Loop until the end of the stream
+        // During the loop, yield each time we get a chunk from the streaming parser
+        // that is either available or added to the queue
+        while (!stream.streamDone) {
+            const output = await stream.nextChunk();
+            const chunk = output !== null
+                ? (0, gemini_js_1.responseToChatGeneration)({ data: output })
+                : new outputs_1.ChatGenerationChunk({
+                    text: "",
+                    generationInfo: { finishReason: "stop" },
+                    message: new messages_1.AIMessageChunk({
+                        content: "",
+                    }),
+                });
+            yield chunk;
+        }
+    }
+    /** @ignore */
+    _combineLLMOutput() {
+        return [];
+    }
+}
+exports.ChatGoogleBase = ChatGoogleBase;

package/dist/chat_models.d.ts

@@ -0,0 +1,46 @@
+import { type BaseMessage } from "@langchain/core/messages";
+import { type BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
+import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
+import { BaseChatModel, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
+import { ChatGenerationChunk, ChatResult } from "@langchain/core/outputs";
+import { GoogleAIBaseLLMInput, GoogleAIModelParams, GoogleAISafetySetting, GoogleConnectionParams, GooglePlatformType, GeminiContent } from "./types.js";
+import { AbstractGoogleLLMConnection } from "./connection.js";
+import { GoogleAbstractedClient } from "./auth.js";
+import { GoogleBaseLLMInput } from "./llms.js";
+declare class ChatConnection<AuthOptions> extends AbstractGoogleLLMConnection<BaseMessage[], AuthOptions> {
+    formatContents(input: BaseMessage[], _parameters: GoogleAIModelParams): GeminiContent[];
+}
+/**
+ * Input to chat model class.
+ */
+export interface ChatGoogleBaseInput<AuthOptions> extends BaseChatModelParams, GoogleConnectionParams<AuthOptions>, GoogleAIModelParams {
+}
+/**
+ * Integration with a chat model.
+ */
+export declare abstract class ChatGoogleBase<AuthOptions> extends BaseChatModel<BaseLanguageModelCallOptions> implements ChatGoogleBaseInput<AuthOptions> {
+    static lc_name(): string;
+    lc_serializable: boolean;
+    model: string;
+    temperature: number;
+    maxOutputTokens: number;
+    topP: number;
+    topK: number;
+    stopSequences: string[];
+    safetySettings: GoogleAISafetySetting[];
+    protected connection: ChatConnection<AuthOptions>;
+    protected streamedConnection: ChatConnection<AuthOptions>;
+    constructor(fields?: ChatGoogleBaseInput<AuthOptions>);
+    abstract buildAbstractedClient(fields?: GoogleAIBaseLLMInput<AuthOptions>): GoogleAbstractedClient;
+    buildApiKeyClient(apiKey: string): GoogleAbstractedClient;
+    buildApiKey(fields?: GoogleAIBaseLLMInput<AuthOptions>): string | undefined;
+    buildClient(fields?: GoogleAIBaseLLMInput<AuthOptions>): GoogleAbstractedClient;
+    buildConnection(fields: GoogleBaseLLMInput<AuthOptions>, client: GoogleAbstractedClient): void;
+    get platform(): GooglePlatformType;
+    _llmType(): string;
+    _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], _runManager: CallbackManagerForLLMRun | undefined): Promise<ChatResult>;
+    _streamResponseChunks(_messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    /** @ignore */
+    _combineLLMOutput(): never[];
+}
+export {};

package/dist/chat_models.js

@@ -0,0 +1,149 @@
+import { getEnvironmentVariable } from "@langchain/core/utils/env";
+import { BaseChatModel, } from "@langchain/core/language_models/chat_models";
+import { ChatGenerationChunk } from "@langchain/core/outputs";
+import { AIMessageChunk } from "@langchain/core/messages";
+import { copyAIModelParams, copyAndValidateModelParamsInto, } from "./utils/common.js";
+import { AbstractGoogleLLMConnection } from "./connection.js";
+import { baseMessageToContent, responseToChatGeneration, responseToChatResult, } from "./utils/gemini.js";
+import { ApiKeyGoogleAuth } from "./auth.js";
+class ChatConnection extends AbstractGoogleLLMConnection {
+    formatContents(input, _parameters) {
+        return input
+            .map((msg) => baseMessageToContent(msg))
+            .reduce((acc, cur) => [...acc, ...cur]);
+    }
+}
+/**
+ * Integration with a chat model.
+ */
+export class ChatGoogleBase extends BaseChatModel {
+    // Used for tracing, replace with the same name as your class
+    static lc_name() {
+        return "ChatGoogle";
+    }
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "gemini-pro"
+        });
+        Object.defineProperty(this, "temperature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0.7
+        });
+        Object.defineProperty(this, "maxOutputTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1024
+        });
+        Object.defineProperty(this, "topP", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0.8
+        });
+        Object.defineProperty(this, "topK", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 40
+        });
+        Object.defineProperty(this, "stopSequences", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "safetySettings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "connection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "streamedConnection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        copyAndValidateModelParamsInto(fields, this);
+        const client = this.buildClient(fields);
+        this.buildConnection(fields ?? {}, client);
+    }
+    buildApiKeyClient(apiKey) {
+        return new ApiKeyGoogleAuth(apiKey);
+    }
+    buildApiKey(fields) {
+        return fields?.apiKey ?? getEnvironmentVariable("GOOGLE_API_KEY");
+    }
+    buildClient(fields) {
+        const apiKey = this.buildApiKey(fields);
+        if (apiKey) {
+            return this.buildApiKeyClient(apiKey);
+        }
+        else {
+            return this.buildAbstractedClient(fields);
+        }
+    }
+    buildConnection(fields, client) {
+        this.connection = new ChatConnection({ ...fields, ...this }, this.caller, client, false);
+        this.streamedConnection = new ChatConnection({ ...fields, ...this }, this.caller, client, true);
+    }
+    get platform() {
+        return this.connection.platform;
+    }
+    // Replace
+    _llmType() {
+        return "chat_integration";
+    }
+    async _generate(messages, options, _runManager) {
+        const parameters = copyAIModelParams(this);
+        const response = await this.connection.request(messages, parameters, options);
+        const ret = responseToChatResult(response);
+        return ret;
+    }
+    async *_streamResponseChunks(_messages, _options, _runManager) {
+        // Make the call as a streaming request
+        const parameters = copyAIModelParams(this);
+        const response = await this.streamedConnection.request(_messages, parameters, _options);
+        // Get the streaming parser of the response
+        const stream = response.data;
+        // Loop until the end of the stream
+        // During the loop, yield each time we get a chunk from the streaming parser
+        // that is either available or added to the queue
+        while (!stream.streamDone) {
+            const output = await stream.nextChunk();
+            const chunk = output !== null
+                ? responseToChatGeneration({ data: output })
+                : new ChatGenerationChunk({
+                    text: "",
+                    generationInfo: { finishReason: "stop" },
+                    message: new AIMessageChunk({
+                        content: "",
+                    }),
+                });
+            yield chunk;
+        }
+    }
+    /** @ignore */
+    _combineLLMOutput() {
+        return [];
+    }
+}