@langchain/google-common 0.0.0

package/dist/llms.cjs

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleBaseLLM = void 0;
+const llms_1 = require("@langchain/core/language_models/llms");
+const outputs_1 = require("@langchain/core/outputs");
+const env_1 = require("@langchain/core/utils/env");
+const connection_js_1 = require("./connection.cjs");
+const common_js_1 = require("./utils/common.cjs");
+const gemini_js_1 = require("./utils/gemini.cjs");
+const auth_js_1 = require("./auth.cjs");
+class GoogleLLMConnection extends connection_js_1.AbstractGoogleLLMConnection {
+    formatContents(input, _parameters) {
+        const parts = (0, gemini_js_1.messageContentToParts)(input);
+        const contents = [
+            {
+                role: "user",
+                parts,
+            },
+        ];
+        return contents;
+    }
+}
+/**
+ * Integration with an LLM.
+ */
+class GoogleBaseLLM extends llms_1.LLM {
+    // Used for tracing, replace with the same name as your class
+    static lc_name() {
+        return "GoogleLLM";
+    }
+    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 GoogleLLMConnection({ ...fields, ...this }, this.caller, client, false);
+        this.streamedConnection = new GoogleLLMConnection({ ...fields, ...this }, this.caller, client, true);
+    }
+    get platform() {
+        return this.connection.platform;
+    }
+    // Replace
+    _llmType() {
+        return "googlellm";
+    }
+    formatPrompt(prompt) {
+        return prompt;
+    }
+    /**
+     * For some given input string and options, return a string output.
+     */
+    async _call(_prompt, _options, _runManager) {
+        const parameters = (0, common_js_1.copyAIModelParams)(this);
+        const result = await this.connection.request(_prompt, parameters, _options);
+        const ret = (0, gemini_js_1.responseToString)(result);
+        return ret;
+    }
+    async *_streamResponseChunks(_prompt, _options, _runManager) {
+        // Make the call as a streaming request
+        const parameters = (0, common_js_1.copyAIModelParams)(this);
+        const result = await this.streamedConnection.request(_prompt, parameters, _options);
+        // Get the streaming parser of the response
+        const stream = result.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
+                ? new outputs_1.GenerationChunk((0, gemini_js_1.responseToGeneration)({ data: output }))
+                : new outputs_1.GenerationChunk({
+                    text: "",
+                    generationInfo: { finishReason: "stop" },
+                });
+            yield chunk;
+        }
+    }
+    async predictMessages(messages, options, _callbacks) {
+        const { content } = messages[0];
+        const result = await this.connection.request(content, {}, options);
+        const ret = (0, gemini_js_1.responseToBaseMessage)(result);
+        return ret;
+    }
+}
+exports.GoogleBaseLLM = GoogleBaseLLM;

package/dist/llms.d.ts

@@ -0,0 +1,48 @@
+import { CallbackManagerForLLMRun, Callbacks } from "@langchain/core/callbacks/manager";
+import { LLM } from "@langchain/core/language_models/llms";
+import { type BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
+import { BaseMessage, MessageContent } from "@langchain/core/messages";
+import { GenerationChunk } from "@langchain/core/outputs";
+import { AbstractGoogleLLMConnection } from "./connection.js";
+import { GoogleAIBaseLLMInput, GoogleAIModelParams, GoogleAISafetySetting, GooglePlatformType, GeminiContent } from "./types.js";
+import { GoogleAbstractedClient } from "./auth.js";
+declare class GoogleLLMConnection<AuthOptions> extends AbstractGoogleLLMConnection<MessageContent, AuthOptions> {
+    formatContents(input: MessageContent, _parameters: GoogleAIModelParams): GeminiContent[];
+}
+/**
+ * Input to LLM class.
+ */
+export interface GoogleBaseLLMInput<AuthOptions> extends GoogleAIBaseLLMInput<AuthOptions> {
+}
+/**
+ * Integration with an LLM.
+ */
+export declare abstract class GoogleBaseLLM<AuthOptions> extends LLM<BaseLanguageModelCallOptions> implements GoogleBaseLLMInput<AuthOptions> {
+    static lc_name(): string;
+    lc_serializable: boolean;
+    model: string;
+    temperature: number;
+    maxOutputTokens: number;
+    topP: number;
+    topK: number;
+    stopSequences: string[];
+    safetySettings: GoogleAISafetySetting[];
+    protected connection: GoogleLLMConnection<AuthOptions>;
+    protected streamedConnection: GoogleLLMConnection<AuthOptions>;
+    constructor(fields?: GoogleBaseLLMInput<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;
+    formatPrompt(prompt: string): MessageContent;
+    /**
+     * For some given input string and options, return a string output.
+     */
+    _call(_prompt: string, _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<string>;
+    _streamResponseChunks(_prompt: string, _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;
+    predictMessages(messages: BaseMessage[], options?: string[] | BaseLanguageModelCallOptions, _callbacks?: Callbacks): Promise<BaseMessage>;
+}
+export {};

package/dist/llms.js

@@ -0,0 +1,158 @@
+import { LLM } from "@langchain/core/language_models/llms";
+import { GenerationChunk } from "@langchain/core/outputs";
+import { getEnvironmentVariable } from "@langchain/core/utils/env";
+import { AbstractGoogleLLMConnection } from "./connection.js";
+import { copyAIModelParams, copyAndValidateModelParamsInto, } from "./utils/common.js";
+import { messageContentToParts, responseToBaseMessage, responseToGeneration, responseToString, } from "./utils/gemini.js";
+import { ApiKeyGoogleAuth } from "./auth.js";
+class GoogleLLMConnection extends AbstractGoogleLLMConnection {
+    formatContents(input, _parameters) {
+        const parts = messageContentToParts(input);
+        const contents = [
+            {
+                role: "user",
+                parts,
+            },
+        ];
+        return contents;
+    }
+}
+/**
+ * Integration with an LLM.
+ */
+export class GoogleBaseLLM extends LLM {
+    // Used for tracing, replace with the same name as your class
+    static lc_name() {
+        return "GoogleLLM";
+    }
+    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 GoogleLLMConnection({ ...fields, ...this }, this.caller, client, false);
+        this.streamedConnection = new GoogleLLMConnection({ ...fields, ...this }, this.caller, client, true);
+    }
+    get platform() {
+        return this.connection.platform;
+    }
+    // Replace
+    _llmType() {
+        return "googlellm";
+    }
+    formatPrompt(prompt) {
+        return prompt;
+    }
+    /**
+     * For some given input string and options, return a string output.
+     */
+    async _call(_prompt, _options, _runManager) {
+        const parameters = copyAIModelParams(this);
+        const result = await this.connection.request(_prompt, parameters, _options);
+        const ret = responseToString(result);
+        return ret;
+    }
+    async *_streamResponseChunks(_prompt, _options, _runManager) {
+        // Make the call as a streaming request
+        const parameters = copyAIModelParams(this);
+        const result = await this.streamedConnection.request(_prompt, parameters, _options);
+        // Get the streaming parser of the response
+        const stream = result.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
+                ? new GenerationChunk(responseToGeneration({ data: output }))
+                : new GenerationChunk({
+                    text: "",
+                    generationInfo: { finishReason: "stop" },
+                });
+            yield chunk;
+        }
+    }
+    async predictMessages(messages, options, _callbacks) {
+        const { content } = messages[0];
+        const result = await this.connection.request(content, {}, options);
+        const ret = responseToBaseMessage(result);
+        return ret;
+    }
+}

package/dist/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types.d.ts

@@ -0,0 +1,146 @@
+import type { BaseLLMParams } from "@langchain/core/language_models/llms";
+import type { JsonStream } from "./utils/stream.js";
+/**
+ * Parameters needed to setup the client connection.
+ * AuthOptions are something like GoogleAuthOptions (from google-auth-library)
+ * or WebGoogleAuthOptions.
+ */
+export interface GoogleClientParams<AuthOptions> {
+    authOptions?: AuthOptions;
+    /** Some APIs allow an API key instead */
+    apiKey?: string;
+}
+/**
+ * What platform is this running on?
+ * gai - Google AI Studio / MakerSuite / Generative AI platform
+ * gcp - Google Cloud Platform
+ */
+export type GooglePlatformType = "gai" | "gcp";
+export interface GoogleConnectionParams<AuthOptions> extends GoogleClientParams<AuthOptions> {
+    /** Hostname for the API call (if this is running on GCP) */
+    endpoint?: string;
+    /** Region where the LLM is stored (if this is running on GCP) */
+    location?: string;
+    /** The version of the API functions. Part of the path. */
+    apiVersion?: string;
+    /**
+     * What platform to run the service on.
+     * If not specified, the class should determine this from other
+     * means. Either way, the platform actually used will be in
+     * the "platform" getter.
+     */
+    platformType?: GooglePlatformType;
+}
+export interface GoogleAISafetySetting {
+    category: string;
+    threshold: string;
+}
+export interface GoogleAIModelParams {
+    /** Model to use */
+    model?: string;
+    /** Sampling temperature to use */
+    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).
+     */
+    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).
+     */
+    topK?: number;
+    stopSequences?: string[];
+    safetySettings?: GoogleAISafetySetting[];
+}
+export interface GoogleAIBaseLLMInput<AuthOptions> extends BaseLLMParams, GoogleConnectionParams<AuthOptions>, GoogleAIModelParams {
+}
+export interface GoogleResponse {
+    data: any;
+}
+export interface GeminiPartText {
+    text: string;
+}
+export interface GeminiPartInlineData {
+    mimeType: string;
+    data: string;
+}
+export interface GeminiPartFileData {
+    mimeType: string;
+    fileUri: string;
+}
+export interface GeminiPartFunctionCall {
+    name: string;
+    args?: object;
+}
+export interface GeminiPartFunctionResponse {
+    name: string;
+    response: object;
+}
+export type GeminiPart = GeminiPartText | GeminiPartInlineData | GeminiPartFileData | GeminiPartFunctionCall | GeminiPartFunctionResponse;
+export interface GeminiSafetySetting {
+    category: string;
+    threshold: string;
+}
+export interface GeminiSafetyRating {
+    category: string;
+    probability: string;
+}
+export type GeminiRole = "user" | "model";
+export interface GeminiContent {
+    parts: GeminiPart[];
+    role: GeminiRole;
+}
+export interface GeminiTool {
+}
+export interface GeminiGenerationConfig {
+    stopSequences?: string[];
+    candidateCount?: number;
+    maxOutputTokens?: number;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+}
+export interface GeminiRequest {
+    contents?: GeminiContent[];
+    tools?: GeminiTool[];
+    safetySettings?: GeminiSafetySetting[];
+    generationConfig?: GeminiGenerationConfig;
+}
+interface GeminiResponseCandidate {
+    content: {
+        parts: GeminiPart[];
+        role: string;
+    };
+    finishReason: string;
+    index: number;
+    tokenCount?: number;
+    safetyRatings: GeminiSafetyRating[];
+}
+interface GeminiResponsePromptFeedback {
+    safetyRatings: GeminiSafetyRating[];
+}
+export interface GenerateContentResponseData {
+    candidates: GeminiResponseCandidate[];
+    promptFeedback: GeminiResponsePromptFeedback;
+}
+export type GoogleLLMModelFamily = null | "palm" | "gemini";
+export type GoogleLLMResponseData = JsonStream | GenerateContentResponseData | GenerateContentResponseData[];
+export interface GoogleLLMResponse extends GoogleResponse {
+    data: GoogleLLMResponseData;
+}
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/common.cjs

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyAndValidateModelParamsInto = exports.validateModelParams = exports.modelToFamily = exports.copyAIModelParamsInto = exports.copyAIModelParams = void 0;
+const gemini_js_1 = require("./gemini.cjs");
+function copyAIModelParams(params) {
+    return copyAIModelParamsInto(params, {});
+}
+exports.copyAIModelParams = copyAIModelParams;
+function copyAIModelParamsInto(params, target) {
+    const ret = target || {};
+    ret.model = params?.model ?? target.model;
+    ret.temperature = params?.temperature ?? target.temperature;
+    ret.maxOutputTokens = params?.maxOutputTokens ?? target.maxOutputTokens;
+    ret.topP = params?.topP ?? target.topP;
+    ret.topK = params?.topK ?? target.topK;
+    ret.stopSequences = params?.stopSequences ?? target.stopSequences;
+    ret.safetySettings = params?.safetySettings ?? target.safetySettings;
+    return ret;
+}
+exports.copyAIModelParamsInto = copyAIModelParamsInto;
+function modelToFamily(modelName) {
+    if (!modelName) {
+        return null;
+    }
+    else if ((0, gemini_js_1.isModelGemini)(modelName)) {
+        return "gemini";
+    }
+    else {
+        return null;
+    }
+}
+exports.modelToFamily = modelToFamily;
+function validateModelParams(params) {
+    const testParams = params ?? {};
+    switch (modelToFamily(testParams.model)) {
+        case "gemini":
+            return (0, gemini_js_1.validateGeminiParams)(testParams);
+        default:
+            throw new Error(`Unable to verify model params: ${JSON.stringify(params)}`);
+    }
+}
+exports.validateModelParams = validateModelParams;
+function copyAndValidateModelParamsInto(params, target) {
+    copyAIModelParamsInto(params, target);
+    validateModelParams(target);
+    return target;
+}
+exports.copyAndValidateModelParamsInto = copyAndValidateModelParamsInto;

package/dist/utils/common.d.ts

@@ -0,0 +1,6 @@
+import type { GoogleAIModelParams, GoogleLLMModelFamily } from "../types.js";
+export declare function copyAIModelParams(params: GoogleAIModelParams | undefined): GoogleAIModelParams;
+export declare function copyAIModelParamsInto(params: GoogleAIModelParams | undefined, target: GoogleAIModelParams): GoogleAIModelParams;
+export declare function modelToFamily(modelName: string | undefined): GoogleLLMModelFamily;
+export declare function validateModelParams(params: GoogleAIModelParams | undefined): void;
+export declare function copyAndValidateModelParamsInto(params: GoogleAIModelParams | undefined, target: GoogleAIModelParams): GoogleAIModelParams;

package/dist/utils/common.js

@@ -0,0 +1,40 @@
+import { isModelGemini, validateGeminiParams } from "./gemini.js";
+export function copyAIModelParams(params) {
+    return copyAIModelParamsInto(params, {});
+}
+export function copyAIModelParamsInto(params, target) {
+    const ret = target || {};
+    ret.model = params?.model ?? target.model;
+    ret.temperature = params?.temperature ?? target.temperature;
+    ret.maxOutputTokens = params?.maxOutputTokens ?? target.maxOutputTokens;
+    ret.topP = params?.topP ?? target.topP;
+    ret.topK = params?.topK ?? target.topK;
+    ret.stopSequences = params?.stopSequences ?? target.stopSequences;
+    ret.safetySettings = params?.safetySettings ?? target.safetySettings;
+    return ret;
+}
+export function modelToFamily(modelName) {
+    if (!modelName) {
+        return null;
+    }
+    else if (isModelGemini(modelName)) {
+        return "gemini";
+    }
+    else {
+        return null;
+    }
+}
+export function validateModelParams(params) {
+    const testParams = params ?? {};
+    switch (modelToFamily(testParams.model)) {
+        case "gemini":
+            return validateGeminiParams(testParams);
+        default:
+            throw new Error(`Unable to verify model params: ${JSON.stringify(params)}`);
+    }
+}
+export function copyAndValidateModelParamsInto(params, target) {
+    copyAIModelParamsInto(params, target);
+    validateModelParams(target);
+    return target;
+}