@langchain/google-common 0.2.14 → 0.2.15

package/dist/connection.d.ts

@@ -2,7 +2,7 @@ import { BaseLanguageModelCallOptions } from "@langchain/core/language_models/ba
 import { AsyncCaller, AsyncCallerCallOptions } from "@langchain/core/utils/async_caller";
 import { BaseRunManager } from "@langchain/core/callbacks/manager";
 import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
-import type { GoogleAIBaseLLMInput, GoogleConnectionParams, GooglePlatformType, GoogleResponse, GoogleLLMResponse, GoogleAIModelRequestParams, GoogleRawResponse, GoogleAIAPI, VertexModelFamily, GoogleAIAPIConfig } from "./types.js";
+import type { GoogleAIBaseLLMInput, GoogleConnectionParams, GooglePlatformType, GoogleResponse, GoogleLLMResponse, GoogleAIModelRequestParams, GoogleRawResponse, GoogleAIAPI, VertexModelFamily, GoogleAIAPIConfig, GoogleModelParams } from "./types.js";
 import { GoogleAbstractedClient, GoogleAbstractedClientOps, GoogleAbstractedClientOpsMethod } from "./auth.js";
 export declare abstract class GoogleConnection<CallOptions extends AsyncCallerCallOptions, ResponseType extends GoogleResponse> {
     caller: AsyncCaller;
@@ -64,7 +64,7 @@ export declare abstract class GoogleAIConnection<CallOptions extends AsyncCaller
     buildUrlVertexLocation(): Promise<string>;
     buildUrlVertex(): Promise<string>;
     buildUrl(): Promise<string>;
-    abstract formatData(input: InputType, parameters: GoogleAIModelRequestParams): Promise<unknown>;
+    abstract formatData(input: InputType, parameters: GoogleModelParams): Promise<unknown>;
     request(input: InputType, parameters: GoogleAIModelRequestParams, options: CallOptions, runManager?: BaseRunManager): Promise<ResponseType>;
 }
 export declare abstract class AbstractGoogleLLMConnection<MessageType, AuthOptions> extends GoogleAIConnection<BaseLanguageModelCallOptions, MessageType, AuthOptions, GoogleLLMResponse> {

package/dist/embeddings.cjs

@@ -16,19 +16,63 @@ class EmbeddingsConnection extends connection_js_1.GoogleAIConnection {
             value: void 0
         });
     }
-    async buildUrlMethod() {
+    buildUrlMethodAiStudio() {
+        return "embedContent";
+    }
+    buildUrlMethodVertex() {
         return "predict";
     }
+    async buildUrlMethod() {
+        switch (this.platform) {
+            case "gcp":
+                return this.buildUrlMethodVertex();
+            case "gai":
+                return this.buildUrlMethodAiStudio();
+            default:
+                throw new Error(`Unknown platform when building method: ${this.platform}`);
+        }
+    }
     get modelPublisher() {
         // All the embedding models are currently published by "google"
         return "google";
     }
-    async formatData(input, parameters) {
+    formatDataAiStudio(input, parameters) {
+        const parts = input.map((instance) => ({
+            text: instance.content,
+        }));
+        const content = {
+            parts,
+        };
+        const outputDimensionality = parameters?.outputDimensionality;
+        const ret = {
+            content,
+            outputDimensionality,
+        };
+        // Remove undefined attributes
+        let key;
+        for (key in ret) {
+            if (ret[key] === undefined) {
+                delete ret[key];
+            }
+        }
+        return ret;
+    }
+    formatDataVertex(input, parameters) {
         return {
             instances: input,
             parameters,
         };
     }
+    async formatData(input, parameters) {
+        switch (this.platform) {
+            case "gcp":
+                return this.formatDataVertex(input, parameters);
+            case "gai":
+                return this.formatDataAiStudio(input, parameters);
+            default:
+                throw new Error(`Unknown platform to format embeddings ${this.platform}`);
+        }
+    }
 }
 /**
  * Enables calls to Google APIs for generating
@@ -43,6 +87,12 @@ class BaseGoogleEmbeddings extends embeddings_1.Embeddings {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "dimensions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "connection", {
             enumerable: true,
             configurable: true,
@@ -50,6 +100,7 @@ class BaseGoogleEmbeddings extends embeddings_1.Embeddings {
             value: void 0
         });
         this.model = fields.model;
+        this.dimensions = fields.dimensions ?? fields.outputDimensionality;
         this.connection = new EmbeddingsConnection({ ...fields, ...this }, this.caller, this.buildClient(fields), false);
     }
     buildApiKeyClient(apiKey) {
@@ -67,6 +118,37 @@ class BaseGoogleEmbeddings extends embeddings_1.Embeddings {
             return this.buildAbstractedClient(fields);
         }
     }
+    buildParameters() {
+        const ret = {
+            outputDimensionality: this.dimensions,
+        };
+        // Remove undefined attributes
+        let key;
+        for (key in ret) {
+            if (ret[key] === undefined) {
+                delete ret[key];
+            }
+        }
+        return ret;
+    }
+    vertexResponseToValues(response) {
+        const predictions = response?.data?.predictions ?? [];
+        return predictions.map((prediction) => prediction.embeddings.values);
+    }
+    aiStudioResponseToValues(response) {
+        const value = response?.data?.embedding?.values ?? [];
+        return [value];
+    }
+    responseToValues(response) {
+        switch (this.connection.platform) {
+            case "gcp":
+                return this.vertexResponseToValues(response);
+            case "gai":
+                return this.aiStudioResponseToValues(response);
+            default:
+                throw new Error(`Unknown response platform: ${this.connection.platform}`);
+        }
+    }
     /**
      * Takes an array of documents as input and returns a promise that
      * resolves to a 2D array of embeddings for each document. It splits the
@@ -76,17 +158,19 @@ class BaseGoogleEmbeddings extends embeddings_1.Embeddings {
      * @returns A promise that resolves to a 2D array of embeddings for each document.
      */
     async embedDocuments(documents) {
+        // Vertex "text-" models could do up 5 documents at once,
+        // but the "gemini-embedding-001" can only do 1.
+        // AI Studio can only do a chunk size of 1.
+        // TODO: Make this configurable
+        const chunkSize = 1;
         const instanceChunks = (0, chunk_array_1.chunkArray)(documents.map((document) => ({
             content: document,
-        })), 5); // Vertex AI accepts max 5 instances per prediction
-        const parameters = {};
+        })), chunkSize);
+        const parameters = this.buildParameters();
         const options = {};
         const responses = await Promise.all(instanceChunks.map((instances) => this.connection.request(instances, parameters, options)));
-        const result = responses
-            ?.map((response) => response?.data?.predictions?.map(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (result) => result.embeddings?.values) ?? [])
-            .flat() ?? [];
+        const result = responses?.map((response) => this.responseToValues(response)).flat() ??
+            [];
         return result;
     }
     /**

package/dist/embeddings.d.ts

@@ -1,58 +1,23 @@
-import { Embeddings, EmbeddingsParams } from "@langchain/core/embeddings";
-import { AsyncCallerCallOptions } from "@langchain/core/utils/async_caller";
+import { Embeddings } from "@langchain/core/embeddings";
 import { GoogleAbstractedClient } from "./auth.js";
-import { GoogleConnectionParams, GoogleResponse } from "./types.js";
-/**
- * Defines the parameters required to initialize a
- * GoogleEmbeddings instance. It extends EmbeddingsParams and
- * GoogleConnectionParams.
- */
-export interface BaseGoogleEmbeddingsParams<AuthOptions> extends EmbeddingsParams, GoogleConnectionParams<AuthOptions> {
-    model: string;
-}
-/**
- * Defines additional options specific to the
- * GoogleEmbeddingsInstance. It extends AsyncCallerCallOptions.
- */
-export interface BaseGoogleEmbeddingsOptions extends AsyncCallerCallOptions {
-}
-/**
- * Represents an instance for generating embeddings using the Google
- * Vertex AI API. It contains the content to be embedded.
- */
-export interface GoogleEmbeddingsInstance {
-    content: string;
-}
-/**
- * Defines the structure of the embeddings results returned by the Google
- * Vertex AI API. It extends GoogleBasePrediction and contains the
- * embeddings and their statistics.
- */
-export interface GoogleEmbeddingsResponse extends GoogleResponse {
-    data: {
-        predictions: {
-            embeddings: {
-                statistics: {
-                    token_count: number;
-                    truncated: boolean;
-                };
-                values: number[];
-            };
-        }[];
-    };
-}
+import { BaseGoogleEmbeddingsParams, GoogleConnectionParams, GoogleEmbeddingsResponse, VertexEmbeddingsParameters, VertexEmbeddingsResponse, AIStudioEmbeddingsResponse } from "./types.js";
 /**
  * Enables calls to Google APIs for generating
  * text embeddings.
  */
 export declare abstract class BaseGoogleEmbeddings<AuthOptions> extends Embeddings implements BaseGoogleEmbeddingsParams<AuthOptions> {
     model: string;
+    dimensions?: number;
     private connection;
     constructor(fields: BaseGoogleEmbeddingsParams<AuthOptions>);
     abstract buildAbstractedClient(fields?: GoogleConnectionParams<AuthOptions>): GoogleAbstractedClient;
     buildApiKeyClient(apiKey: string): GoogleAbstractedClient;
     buildApiKey(fields?: GoogleConnectionParams<AuthOptions>): string | undefined;
     buildClient(fields?: GoogleConnectionParams<AuthOptions>): GoogleAbstractedClient;
+    buildParameters(): VertexEmbeddingsParameters;
+    vertexResponseToValues(response: VertexEmbeddingsResponse): number[][];
+    aiStudioResponseToValues(response: AIStudioEmbeddingsResponse): number[][];
+    responseToValues(response: GoogleEmbeddingsResponse): number[][];
     /**
      * Takes an array of documents as input and returns a promise that
      * resolves to a 2D array of embeddings for each document. It splits the

package/dist/embeddings.js

@@ -13,19 +13,63 @@ class EmbeddingsConnection extends GoogleAIConnection {
             value: void 0
         });
     }
-    async buildUrlMethod() {
+    buildUrlMethodAiStudio() {
+        return "embedContent";
+    }
+    buildUrlMethodVertex() {
         return "predict";
     }
+    async buildUrlMethod() {
+        switch (this.platform) {
+            case "gcp":
+                return this.buildUrlMethodVertex();
+            case "gai":
+                return this.buildUrlMethodAiStudio();
+            default:
+                throw new Error(`Unknown platform when building method: ${this.platform}`);
+        }
+    }
     get modelPublisher() {
         // All the embedding models are currently published by "google"
         return "google";
     }
-    async formatData(input, parameters) {
+    formatDataAiStudio(input, parameters) {
+        const parts = input.map((instance) => ({
+            text: instance.content,
+        }));
+        const content = {
+            parts,
+        };
+        const outputDimensionality = parameters?.outputDimensionality;
+        const ret = {
+            content,
+            outputDimensionality,
+        };
+        // Remove undefined attributes
+        let key;
+        for (key in ret) {
+            if (ret[key] === undefined) {
+                delete ret[key];
+            }
+        }
+        return ret;
+    }
+    formatDataVertex(input, parameters) {
         return {
             instances: input,
             parameters,
         };
     }
+    async formatData(input, parameters) {
+        switch (this.platform) {
+            case "gcp":
+                return this.formatDataVertex(input, parameters);
+            case "gai":
+                return this.formatDataAiStudio(input, parameters);
+            default:
+                throw new Error(`Unknown platform to format embeddings ${this.platform}`);
+        }
+    }
 }
 /**
  * Enables calls to Google APIs for generating
@@ -40,6 +84,12 @@ export class BaseGoogleEmbeddings extends Embeddings {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "dimensions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "connection", {
             enumerable: true,
             configurable: true,
@@ -47,6 +97,7 @@ export class BaseGoogleEmbeddings extends Embeddings {
             value: void 0
         });
         this.model = fields.model;
+        this.dimensions = fields.dimensions ?? fields.outputDimensionality;
         this.connection = new EmbeddingsConnection({ ...fields, ...this }, this.caller, this.buildClient(fields), false);
     }
     buildApiKeyClient(apiKey) {
@@ -64,6 +115,37 @@ export class BaseGoogleEmbeddings extends Embeddings {
             return this.buildAbstractedClient(fields);
         }
     }
+    buildParameters() {
+        const ret = {
+            outputDimensionality: this.dimensions,
+        };
+        // Remove undefined attributes
+        let key;
+        for (key in ret) {
+            if (ret[key] === undefined) {
+                delete ret[key];
+            }
+        }
+        return ret;
+    }
+    vertexResponseToValues(response) {
+        const predictions = response?.data?.predictions ?? [];
+        return predictions.map((prediction) => prediction.embeddings.values);
+    }
+    aiStudioResponseToValues(response) {
+        const value = response?.data?.embedding?.values ?? [];
+        return [value];
+    }
+    responseToValues(response) {
+        switch (this.connection.platform) {
+            case "gcp":
+                return this.vertexResponseToValues(response);
+            case "gai":
+                return this.aiStudioResponseToValues(response);
+            default:
+                throw new Error(`Unknown response platform: ${this.connection.platform}`);
+        }
+    }
     /**
      * Takes an array of documents as input and returns a promise that
      * resolves to a 2D array of embeddings for each document. It splits the
@@ -73,17 +155,19 @@ export class BaseGoogleEmbeddings extends Embeddings {
      * @returns A promise that resolves to a 2D array of embeddings for each document.
      */
     async embedDocuments(documents) {
+        // Vertex "text-" models could do up 5 documents at once,
+        // but the "gemini-embedding-001" can only do 1.
+        // AI Studio can only do a chunk size of 1.
+        // TODO: Make this configurable
+        const chunkSize = 1;
         const instanceChunks = chunkArray(documents.map((document) => ({
             content: document,
-        })), 5); // Vertex AI accepts max 5 instances per prediction
-        const parameters = {};
+        })), chunkSize);
+        const parameters = this.buildParameters();
         const options = {};
         const responses = await Promise.all(instanceChunks.map((instances) => this.connection.request(instances, parameters, options)));
-        const result = responses
-            ?.map((response) => response?.data?.predictions?.map(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (result) => result.embeddings?.values) ?? [])
-            .flat() ?? [];
+        const result = responses?.map((response) => this.responseToValues(response)).flat() ??
+            [];
         return result;
     }
     /**

package/dist/types.d.ts

@@ -2,6 +2,8 @@ import type { BaseLLMParams } from "@langchain/core/language_models/llms";
 import type { BaseChatModelCallOptions, BindToolsInput } from "@langchain/core/language_models/chat_models";
 import { BaseMessage, BaseMessageChunk, MessageContent } from "@langchain/core/messages";
 import { ChatGenerationChunk, ChatResult } from "@langchain/core/outputs";
+import { EmbeddingsParams } from "@langchain/core/embeddings";
+import { AsyncCallerCallOptions } from "@langchain/core/utils/async_caller";
 import type { JsonStream } from "./utils/stream.js";
 import { MediaManager } from "./experimental/utils/media_core.js";
 import { AnthropicResponseData, AnthropicAPIConfig } from "./types-anthropic.js";
@@ -144,7 +146,7 @@ export type GoogleSpeechSimplifiedLanguage = GoogleSpeechVoiceLanguage | GoogleS
  * It can either be the voice (or voices), or the voice or voices with language configuration
  */
 export type GoogleSpeechConfigSimplified = GoogleSpeechVoice | GoogleSpeechSimplifiedLanguage;
-export interface GoogleAIModelParams {
+export interface GoogleModelParams {
     /** Model to use */
     model?: string;
     /**
@@ -152,6 +154,8 @@ export interface GoogleAIModelParams {
      * Alias for `model`
      */
     modelName?: string;
+}
+export interface GoogleAIModelParams extends GoogleModelParams {
     /** Sampling temperature to use */
     temperature?: number;
     /**
@@ -630,3 +634,81 @@ export interface GoogleAIAPIParams {
     apiName?: string;
     apiConfig?: GoogleAIAPIConfig;
 }
+/**
+ * Defines the parameters required to initialize a
+ * GoogleEmbeddings instance. It extends EmbeddingsParams and
+ * GoogleConnectionParams.
+ */
+export interface BaseGoogleEmbeddingsParams<AuthOptions> extends EmbeddingsParams, GoogleConnectionParams<AuthOptions> {
+    model: string;
+    /**
+     * Used to specify output embedding size.
+     * If set, output embeddings will be truncated to the size specified.
+     */
+    dimensions?: number;
+    /**
+     * An alias for "dimensions"
+     */
+    outputDimensionality?: number;
+}
+/**
+ * Defines additional options specific to the
+ * GoogleEmbeddingsInstance. It extends AsyncCallerCallOptions.
+ */
+export interface BaseGoogleEmbeddingsOptions extends AsyncCallerCallOptions {
+}
+export type GoogleEmbeddingsTaskType = "RETRIEVAL_QUERY" | "RETRIEVAL_DOCUMENT" | "SEMANTIC_SIMILARITY" | "CLASSIFICATION" | "CLUSTERING" | "QUESTION_ANSWERING" | "FACT_VERIFICATION" | "CODE_RETRIEVAL_QUERY" | string;
+/**
+ * Represents an instance for generating embeddings using the Google
+ * Vertex AI API. It contains the content to be embedded.
+ */
+export interface VertexEmbeddingsInstance {
+    content: string;
+    taskType?: GoogleEmbeddingsTaskType;
+    title?: string;
+}
+export interface VertexEmbeddingsParameters extends GoogleModelParams {
+    autoTruncate?: boolean;
+    outputDimensionality?: number;
+}
+export interface VertexEmbeddingsRequest {
+    instances: VertexEmbeddingsInstance[];
+    parameters?: VertexEmbeddingsParameters;
+}
+export interface AIStudioEmbeddingsRequest {
+    content: {
+        parts: GeminiPartText[];
+    };
+    model?: string;
+    taskType?: GoogleEmbeddingsTaskType;
+    title?: string;
+    outputDimensionality?: number;
+}
+export type GoogleEmbeddingsRequest = VertexEmbeddingsRequest | AIStudioEmbeddingsRequest;
+export interface VertexEmbeddingsResponsePrediction {
+    embeddings: {
+        statistics: {
+            token_count: number;
+            truncated: boolean;
+        };
+        values: number[];
+    };
+}
+/**
+ * Defines the structure of the embeddings results returned by the Google
+ * Vertex AI API. It extends GoogleBasePrediction and contains the
+ * embeddings and their statistics.
+ */
+export interface VertexEmbeddingsResponse extends GoogleResponse {
+    data: {
+        predictions: VertexEmbeddingsResponsePrediction[];
+    };
+}
+export interface AIStudioEmbeddingsResponse extends GoogleResponse {
+    data: {
+        embedding: {
+            values: number[];
+        };
+    };
+}
+export type GoogleEmbeddingsResponse = VertexEmbeddingsResponse | AIStudioEmbeddingsResponse;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/google-common",
-  "version": "0.2.14",
+  "version": "0.2.15",
   "description": "Core types and classes for Google services.",
   "type": "module",
   "engines": {