@langchain/google-common 0.0.22 → 0.0.24

package/dist/chat_models.cjs

@@ -57,10 +57,23 @@ class ChatConnection extends connection_js_1.AbstractGoogleLLMConnection {
         return input
             .map((msg, i) => (0, gemini_js_1.baseMessageToContent)(msg, input[i - 1], this.useSystemInstruction))
             .reduce((acc, cur) => {
-            // Filter out the system content, since those don't belong
-            // in the actual content.
-            const hasNoSystem = cur.every((content) => content.role !== "system");
-            return hasNoSystem ? [...acc, ...cur] : acc;
+            // Filter out the system content
+            if (cur.every((content) => content.role === "system")) {
+                return acc;
+            }
+            // Combine adjacent function messages
+            if (cur[0]?.role === "function" &&
+                acc.length > 0 &&
+                acc[acc.length - 1].role === "function") {
+                acc[acc.length - 1].parts = [
+                    ...acc[acc.length - 1].parts,
+                    ...cur[0].parts,
+                ];
+            }
+            else {
+                acc.push(...cur);
+            }
+            return acc;
         }, []);
     }
     formatSystemInstruction(input, _parameters) {

package/dist/chat_models.d.ts

@@ -3,15 +3,14 @@ import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
 import { BaseChatModel, LangSmithParams, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
 import { ChatGenerationChunk, ChatResult } from "@langchain/core/outputs";
 import { AIMessageChunk } from "@langchain/core/messages";
-import { BaseLanguageModelInput, StructuredOutputMethodOptions, ToolDefinition } from "@langchain/core/language_models/base";
+import { BaseLanguageModelInput, StructuredOutputMethodOptions } from "@langchain/core/language_models/base";
 import type { z } from "zod";
-import { Runnable, RunnableToolLike } from "@langchain/core/runnables";
+import { Runnable } from "@langchain/core/runnables";
 import { AsyncCaller } from "@langchain/core/utils/async_caller";
-import { StructuredToolInterface } from "@langchain/core/tools";
 import { GoogleAIBaseLLMInput, GoogleAIModelParams, GoogleAISafetySetting, GoogleConnectionParams, GooglePlatformType, GeminiContent, GoogleAIBaseLanguageModelCallOptions } from "./types.js";
 import { AbstractGoogleLLMConnection } from "./connection.js";
 import { GoogleAbstractedClient } from "./auth.js";
-import type { GoogleBaseLLMInput, GoogleAISafetyHandler, GoogleAISafetyParams } from "./types.js";
+import type { GoogleBaseLLMInput, GoogleAISafetyHandler, GoogleAISafetyParams, GoogleAIToolType } from "./types.js";
 declare class ChatConnection<AuthOptions> extends AbstractGoogleLLMConnection<BaseMessage[], AuthOptions> {
     convertSystemMessageToHumanContent: boolean | undefined;
     constructor(fields: GoogleAIBaseLLMInput<AuthOptions> | undefined, caller: AsyncCaller, client: GoogleAbstractedClient, streaming: boolean);
@@ -56,7 +55,7 @@ export declare abstract class ChatGoogleBase<AuthOptions> extends BaseChatModel<
     buildClient(fields?: GoogleAIBaseLLMInput<AuthOptions>): GoogleAbstractedClient;
     buildConnection(fields: GoogleBaseLLMInput<AuthOptions>, client: GoogleAbstractedClient): void;
     get platform(): GooglePlatformType;
-    bindTools(tools: (StructuredToolInterface | Record<string, unknown> | ToolDefinition | RunnableToolLike)[], kwargs?: Partial<GoogleAIBaseLanguageModelCallOptions>): Runnable<BaseLanguageModelInput, AIMessageChunk, GoogleAIBaseLanguageModelCallOptions>;
+    bindTools(tools: GoogleAIToolType[], kwargs?: Partial<GoogleAIBaseLanguageModelCallOptions>): Runnable<BaseLanguageModelInput, AIMessageChunk, GoogleAIBaseLanguageModelCallOptions>;
     _llmType(): string;
     /**
      * Get the parameters used to invoke the model

package/dist/chat_models.js

@@ -54,10 +54,23 @@ class ChatConnection extends AbstractGoogleLLMConnection {
         return input
             .map((msg, i) => baseMessageToContent(msg, input[i - 1], this.useSystemInstruction))
             .reduce((acc, cur) => {
-            // Filter out the system content, since those don't belong
-            // in the actual content.
-            const hasNoSystem = cur.every((content) => content.role !== "system");
-            return hasNoSystem ? [...acc, ...cur] : acc;
+            // Filter out the system content
+            if (cur.every((content) => content.role === "system")) {
+                return acc;
+            }
+            // Combine adjacent function messages
+            if (cur[0]?.role === "function" &&
+                acc.length > 0 &&
+                acc[acc.length - 1].role === "function") {
+                acc[acc.length - 1].parts = [
+                    ...acc[acc.length - 1].parts,
+                    ...cur[0].parts,
+                ];
+            }
+            else {
+                acc.push(...cur);
+            }
+            return acc;
         }, []);
     }
     formatSystemInstruction(input, _parameters) {

package/dist/connection.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractGoogleLLMConnection = exports.GoogleAIConnection = exports.GoogleHostConnection = exports.GoogleConnection = void 0;
 const env_1 = require("@langchain/core/utils/env");
+const function_calling_1 = require("@langchain/core/utils/function_calling");
 const zod_to_gemini_parameters_js_1 = require("./utils/zod_to_gemini_parameters.cjs");
 class GoogleConnection {
     constructor(caller, client, streaming) {
@@ -221,16 +222,11 @@ class AbstractGoogleLLMConnection extends GoogleAIConnection {
     formatSystemInstruction(_input, _parameters) {
         return {};
     }
-    // Borrowed from the OpenAI invocation params test
-    isStructuredToolArray(tools) {
-        return (tools !== undefined &&
-            tools.every((tool) => Array.isArray(tool.lc_namespace)));
-    }
     structuredToolToFunctionDeclaration(tool) {
         const jsonSchema = (0, zod_to_gemini_parameters_js_1.zodToGeminiParameters)(tool.schema);
         return {
             name: tool.name,
-            description: tool.description,
+            description: tool.description ?? `A function available to call.`,
             parameters: jsonSchema,
         };
     }
@@ -246,11 +242,13 @@ class AbstractGoogleLLMConnection extends GoogleAIConnection {
         if (!tools || tools.length === 0) {
             return [];
         }
-        if (this.isStructuredToolArray(tools)) {
+        if (tools.every(function_calling_1.isLangChainTool)) {
             return this.structuredToolsToGeminiTools(tools);
         }
         else {
-            if (tools.length === 1 && !tools[0].functionDeclarations?.length) {
+            if (tools.length === 1 &&
+                (!("functionDeclarations" in tools[0]) ||
+                    !tools[0].functionDeclarations?.length)) {
                 return [];
             }
             return tools;

package/dist/connection.d.ts

@@ -1,6 +1,6 @@
 import { BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
 import { AsyncCaller, AsyncCallerCallOptions } from "@langchain/core/utils/async_caller";
-import { StructuredToolInterface } from "@langchain/core/tools";
+import { StructuredToolParams } from "@langchain/core/tools";
 import type { GoogleAIBaseLLMInput, GoogleConnectionParams, GoogleLLMModelFamily, GooglePlatformType, GoogleResponse, GoogleLLMResponse, GeminiContent, GeminiGenerationConfig, GeminiRequest, GeminiSafetySetting, GeminiTool, GeminiFunctionDeclaration, GoogleAIModelRequestParams } from "./types.js";
 import { GoogleAbstractedClient, GoogleAbstractedClientOpsMethod } from "./auth.js";
 export declare abstract class GoogleConnection<CallOptions extends AsyncCallerCallOptions, ResponseType extends GoogleResponse> {
@@ -28,7 +28,7 @@ export declare abstract class GoogleHostConnection<CallOptions extends AsyncCall
     get computedPlatformType(): GooglePlatformType;
     buildMethod(): GoogleAbstractedClientOpsMethod;
 }
-export declare abstract class GoogleAIConnection<CallOptions extends BaseLanguageModelCallOptions, MessageType, AuthOptions> extends GoogleHostConnection<CallOptions, GoogleLLMResponse, AuthOptions> implements GoogleAIBaseLLMInput<AuthOptions> {
+export declare abstract class GoogleAIConnection<CallOptions extends AsyncCallerCallOptions, InputType, AuthOptions, ResponseType extends GoogleResponse> extends GoogleHostConnection<CallOptions, ResponseType, AuthOptions> implements GoogleAIBaseLLMInput<AuthOptions> {
     model: string;
     modelName: string;
     client: GoogleAbstractedClient;
@@ -39,19 +39,18 @@ export declare abstract class GoogleAIConnection<CallOptions extends BaseLanguag
     buildUrlGenerativeLanguage(): Promise<string>;
     buildUrlVertex(): Promise<string>;
     buildUrl(): Promise<string>;
-    abstract formatData(input: MessageType, parameters: GoogleAIModelRequestParams): unknown;
-    request(input: MessageType, parameters: GoogleAIModelRequestParams, options: CallOptions): Promise<GoogleLLMResponse>;
+    abstract formatData(input: InputType, parameters: GoogleAIModelRequestParams): unknown;
+    request(input: InputType, parameters: GoogleAIModelRequestParams, options: CallOptions): Promise<ResponseType>;
 }
-export declare abstract class AbstractGoogleLLMConnection<MessageType, AuthOptions> extends GoogleAIConnection<BaseLanguageModelCallOptions, MessageType, AuthOptions> {
+export declare abstract class AbstractGoogleLLMConnection<MessageType, AuthOptions> extends GoogleAIConnection<BaseLanguageModelCallOptions, MessageType, AuthOptions, GoogleLLMResponse> {
     buildUrlMethodGemini(): Promise<string>;
     buildUrlMethod(): Promise<string>;
     abstract formatContents(input: MessageType, parameters: GoogleAIModelRequestParams): GeminiContent[];
     formatGenerationConfig(_input: MessageType, parameters: GoogleAIModelRequestParams): GeminiGenerationConfig;
     formatSafetySettings(_input: MessageType, parameters: GoogleAIModelRequestParams): GeminiSafetySetting[];
     formatSystemInstruction(_input: MessageType, _parameters: GoogleAIModelRequestParams): GeminiContent;
-    isStructuredToolArray(tools?: unknown[]): tools is StructuredToolInterface[];
-    structuredToolToFunctionDeclaration(tool: StructuredToolInterface): GeminiFunctionDeclaration;
-    structuredToolsToGeminiTools(tools: StructuredToolInterface[]): GeminiTool[];
+    structuredToolToFunctionDeclaration(tool: StructuredToolParams): GeminiFunctionDeclaration;
+    structuredToolsToGeminiTools(tools: StructuredToolParams[]): GeminiTool[];
     formatTools(_input: MessageType, parameters: GoogleAIModelRequestParams): GeminiTool[];
     formatToolConfig(parameters: GoogleAIModelRequestParams): GeminiRequest["toolConfig"] | undefined;
     formatData(input: MessageType, parameters: GoogleAIModelRequestParams): GeminiRequest;

package/dist/connection.js

@@ -1,4 +1,5 @@
 import { getRuntimeEnvironment } from "@langchain/core/utils/env";
+import { isLangChainTool } from "@langchain/core/utils/function_calling";
 import { zodToGeminiParameters } from "./utils/zod_to_gemini_parameters.js";
 export class GoogleConnection {
     constructor(caller, client, streaming) {
@@ -215,16 +216,11 @@ export class AbstractGoogleLLMConnection extends GoogleAIConnection {
     formatSystemInstruction(_input, _parameters) {
         return {};
     }
-    // Borrowed from the OpenAI invocation params test
-    isStructuredToolArray(tools) {
-        return (tools !== undefined &&
-            tools.every((tool) => Array.isArray(tool.lc_namespace)));
-    }
     structuredToolToFunctionDeclaration(tool) {
         const jsonSchema = zodToGeminiParameters(tool.schema);
         return {
             name: tool.name,
-            description: tool.description,
+            description: tool.description ?? `A function available to call.`,
             parameters: jsonSchema,
         };
     }
@@ -240,11 +236,13 @@ export class AbstractGoogleLLMConnection extends GoogleAIConnection {
         if (!tools || tools.length === 0) {
             return [];
         }
-        if (this.isStructuredToolArray(tools)) {
+        if (tools.every(isLangChainTool)) {
             return this.structuredToolsToGeminiTools(tools);
         }
         else {
-            if (tools.length === 1 && !tools[0].functionDeclarations?.length) {
+            if (tools.length === 1 &&
+                (!("functionDeclarations" in tools[0]) ||
+                    !tools[0].functionDeclarations?.length)) {
                 return [];
             }
             return tools;

package/dist/embeddings.cjs

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseGoogleEmbeddings = void 0;
+const embeddings_1 = require("@langchain/core/embeddings");
+const chunk_array_1 = require("@langchain/core/utils/chunk_array");
+const env_1 = require("@langchain/core/utils/env");
+const connection_js_1 = require("./connection.cjs");
+const auth_js_1 = require("./auth.cjs");
+class EmbeddingsConnection extends connection_js_1.GoogleAIConnection {
+    constructor(fields, caller, client, streaming) {
+        super(fields, caller, client, streaming);
+        Object.defineProperty(this, "convertSystemMessageToHumanContent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    async buildUrlMethod() {
+        return "predict";
+    }
+    formatData(input, parameters) {
+        return {
+            instances: input,
+            parameters,
+        };
+    }
+}
+/**
+ * Enables calls to the Google Cloud's Vertex AI API to access
+ * the embeddings generated by Large Language Models.
+ *
+ * To use, you will need to have one of the following authentication
+ * methods in place:
+ * - You are logged into an account permitted to the Google Cloud project
+ *   using Vertex AI.
+ * - You are running this on a machine using a service account permitted to
+ *   the Google Cloud project using Vertex AI.
+ * - The `GOOGLE_APPLICATION_CREDENTIALS` environment variable is set to the
+ *   path of a credentials file for a service account permitted to the
+ *   Google Cloud project using Vertex AI.
+ * @example
+ * ```typescript
+ * const model = new GoogleEmbeddings();
+ * const res = await model.embedQuery(
+ *   "What would be a good company name for a company that makes colorful socks?"
+ * );
+ * console.log({ res });
+ * ```
+ */
+class BaseGoogleEmbeddings extends embeddings_1.Embeddings {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "connection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.model = fields.model;
+        this.connection = new EmbeddingsConnection({ ...fields, ...this }, this.caller, this.buildClient(fields), false);
+    }
+    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);
+        }
+    }
+    /**
+     * 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
+     * documents into chunks and makes requests to the Google Vertex AI API to
+     * generate embeddings.
+     * @param documents An array of documents to be embedded.
+     * @returns A promise that resolves to a 2D array of embeddings for each document.
+     */
+    async embedDocuments(documents) {
+        const instanceChunks = (0, chunk_array_1.chunkArray)(documents.map((document) => ({
+            content: document,
+        })), 5); // Vertex AI accepts max 5 instances per prediction
+        const parameters = {};
+        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((result) => result.embeddings.values) ?? [])
+            .flat() ?? [];
+        return result;
+    }
+    /**
+     * Takes a document as input and returns a promise that resolves to an
+     * embedding for the document. It calls the embedDocuments method with the
+     * document as the input.
+     * @param document A document to be embedded.
+     * @returns A promise that resolves to an embedding for the document.
+     */
+    async embedQuery(document) {
+        const data = await this.embedDocuments([document]);
+        return data[0];
+    }
+}
+exports.BaseGoogleEmbeddings = BaseGoogleEmbeddings;

package/dist/embeddings.d.ts

@@ -0,0 +1,91 @@
+import { Embeddings, EmbeddingsParams } from "@langchain/core/embeddings";
+import { AsyncCallerCallOptions } from "@langchain/core/utils/async_caller";
+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[];
+            };
+        }[];
+    };
+}
+/**
+ * Enables calls to the Google Cloud's Vertex AI API to access
+ * the embeddings generated by Large Language Models.
+ *
+ * To use, you will need to have one of the following authentication
+ * methods in place:
+ * - You are logged into an account permitted to the Google Cloud project
+ *   using Vertex AI.
+ * - You are running this on a machine using a service account permitted to
+ *   the Google Cloud project using Vertex AI.
+ * - The `GOOGLE_APPLICATION_CREDENTIALS` environment variable is set to the
+ *   path of a credentials file for a service account permitted to the
+ *   Google Cloud project using Vertex AI.
+ * @example
+ * ```typescript
+ * const model = new GoogleEmbeddings();
+ * const res = await model.embedQuery(
+ *   "What would be a good company name for a company that makes colorful socks?"
+ * );
+ * console.log({ res });
+ * ```
+ */
+export declare abstract class BaseGoogleEmbeddings<AuthOptions> extends Embeddings implements BaseGoogleEmbeddingsParams<AuthOptions> {
+    model: string;
+    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;
+    /**
+     * 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
+     * documents into chunks and makes requests to the Google Vertex AI API to
+     * generate embeddings.
+     * @param documents An array of documents to be embedded.
+     * @returns A promise that resolves to a 2D array of embeddings for each document.
+     */
+    embedDocuments(documents: string[]): Promise<number[][]>;
+    /**
+     * Takes a document as input and returns a promise that resolves to an
+     * embedding for the document. It calls the embedDocuments method with the
+     * document as the input.
+     * @param document A document to be embedded.
+     * @returns A promise that resolves to an embedding for the document.
+     */
+    embedQuery(document: string): Promise<number[]>;
+}

package/dist/embeddings.js

@@ -0,0 +1,112 @@
+import { Embeddings } from "@langchain/core/embeddings";
+import { chunkArray } from "@langchain/core/utils/chunk_array";
+import { getEnvironmentVariable } from "@langchain/core/utils/env";
+import { GoogleAIConnection } from "./connection.js";
+import { ApiKeyGoogleAuth } from "./auth.js";
+class EmbeddingsConnection extends GoogleAIConnection {
+    constructor(fields, caller, client, streaming) {
+        super(fields, caller, client, streaming);
+        Object.defineProperty(this, "convertSystemMessageToHumanContent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    async buildUrlMethod() {
+        return "predict";
+    }
+    formatData(input, parameters) {
+        return {
+            instances: input,
+            parameters,
+        };
+    }
+}
+/**
+ * Enables calls to the Google Cloud's Vertex AI API to access
+ * the embeddings generated by Large Language Models.
+ *
+ * To use, you will need to have one of the following authentication
+ * methods in place:
+ * - You are logged into an account permitted to the Google Cloud project
+ *   using Vertex AI.
+ * - You are running this on a machine using a service account permitted to
+ *   the Google Cloud project using Vertex AI.
+ * - The `GOOGLE_APPLICATION_CREDENTIALS` environment variable is set to the
+ *   path of a credentials file for a service account permitted to the
+ *   Google Cloud project using Vertex AI.
+ * @example
+ * ```typescript
+ * const model = new GoogleEmbeddings();
+ * const res = await model.embedQuery(
+ *   "What would be a good company name for a company that makes colorful socks?"
+ * );
+ * console.log({ res });
+ * ```
+ */
+export class BaseGoogleEmbeddings extends Embeddings {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "connection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.model = fields.model;
+        this.connection = new EmbeddingsConnection({ ...fields, ...this }, this.caller, this.buildClient(fields), false);
+    }
+    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);
+        }
+    }
+    /**
+     * 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
+     * documents into chunks and makes requests to the Google Vertex AI API to
+     * generate embeddings.
+     * @param documents An array of documents to be embedded.
+     * @returns A promise that resolves to a 2D array of embeddings for each document.
+     */
+    async embedDocuments(documents) {
+        const instanceChunks = chunkArray(documents.map((document) => ({
+            content: document,
+        })), 5); // Vertex AI accepts max 5 instances per prediction
+        const parameters = {};
+        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((result) => result.embeddings.values) ?? [])
+            .flat() ?? [];
+        return result;
+    }
+    /**
+     * Takes a document as input and returns a promise that resolves to an
+     * embedding for the document. It calls the embedDocuments method with the
+     * document as the input.
+     * @param document A document to be embedded.
+     * @returns A promise that resolves to an embedding for the document.
+     */
+    async embedQuery(document) {
+        const data = await this.embedDocuments([document]);
+        return data[0];
+    }
+}

package/dist/index.cjs

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./chat_models.cjs"), exports);
 __exportStar(require("./llms.cjs"), exports);
+__exportStar(require("./embeddings.cjs"), exports);
 __exportStar(require("./auth.cjs"), exports);
 __exportStar(require("./connection.cjs"), exports);
 __exportStar(require("./types.cjs"), exports);

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./chat_models.js";
 export * from "./llms.js";
+export * from "./embeddings.js";
 export * from "./auth.js";
 export * from "./connection.js";
 export * from "./types.js";

package/dist/index.js

@@ -1,5 +1,6 @@
 export * from "./chat_models.js";
 export * from "./llms.js";
+export * from "./embeddings.js";
 export * from "./auth.js";
 export * from "./connection.js";
 export * from "./types.js";

package/dist/types.d.ts

@@ -1,6 +1,5 @@
 import type { BaseLLMParams } from "@langchain/core/language_models/llms";
-import { StructuredToolInterface } from "@langchain/core/tools";
-import type { BaseChatModelCallOptions } from "@langchain/core/language_models/chat_models";
+import type { BaseChatModelCallOptions, BindToolsInput } from "@langchain/core/language_models/chat_models";
 import type { JsonStream } from "./utils/stream.js";
 /**
  * Parameters needed to setup the client connection.
@@ -36,6 +35,7 @@ export interface GoogleConnectionParams<AuthOptions> extends GoogleClientParams<
 export interface GoogleAISafetySetting {
     category: string;
     threshold: string;
+    method?: string;
 }
 export type GoogleAIResponseMimeType = "text/plain" | "application/json";
 export interface GoogleAIModelParams {
@@ -91,11 +91,12 @@ export interface GoogleAIModelParams {
      */
     streaming?: boolean;
 }
+export type GoogleAIToolType = BindToolsInput | GeminiTool;
 /**
  * The params which can be passed to the API at request time.
  */
 export interface GoogleAIModelRequestParams extends GoogleAIModelParams {
-    tools?: StructuredToolInterface[] | GeminiTool[];
+    tools?: GoogleAIToolType[];
     /**
      * Force the model to use tools in a specific way.
      *

package/dist/utils/common.cjs

@@ -36,35 +36,35 @@ function processToolChoice(toolChoice, allowedFunctionNames) {
     }
     throw new Error("Object inputs for tool_choice not supported.");
 }
-function convertToGeminiTools(structuredTools) {
-    const tools = [
+function convertToGeminiTools(tools) {
+    const geminiTools = [
         {
             functionDeclarations: [],
         },
     ];
-    structuredTools.forEach((tool) => {
+    tools.forEach((tool) => {
         if ("functionDeclarations" in tool &&
             Array.isArray(tool.functionDeclarations)) {
             const funcs = tool.functionDeclarations;
-            tools[0].functionDeclarations?.push(...funcs);
+            geminiTools[0].functionDeclarations?.push(...funcs);
         }
-        else if ((0, function_calling_1.isStructuredTool)(tool)) {
+        else if ((0, function_calling_1.isLangChainTool)(tool)) {
             const jsonSchema = (0, zod_to_gemini_parameters_js_1.zodToGeminiParameters)(tool.schema);
-            tools[0].functionDeclarations?.push({
+            geminiTools[0].functionDeclarations?.push({
                 name: tool.name,
-                description: tool.description,
+                description: tool.description ?? `A function available to call.`,
                 parameters: jsonSchema,
             });
         }
         else if ((0, base_1.isOpenAITool)(tool)) {
-            tools[0].functionDeclarations?.push({
+            geminiTools[0].functionDeclarations?.push({
                 name: tool.function.name,
                 description: tool.function.description ?? `A function available to call.`,
                 parameters: (0, zod_to_gemini_parameters_js_1.jsonSchemaToGeminiParameters)(tool.function.parameters),
             });
         }
     });
-    return tools;
+    return geminiTools;
 }
 exports.convertToGeminiTools = convertToGeminiTools;
 function copyAIModelParamsInto(params, options, target) {

package/dist/utils/common.d.ts

@@ -1,9 +1,6 @@
-import { StructuredToolInterface } from "@langchain/core/tools";
-import { ToolDefinition } from "@langchain/core/language_models/base";
-import { RunnableToolLike } from "@langchain/core/runnables";
-import type { GeminiTool, GoogleAIBaseLanguageModelCallOptions, GoogleAIModelParams, GoogleAIModelRequestParams, GoogleLLMModelFamily } from "../types.js";
+import type { GeminiTool, GoogleAIBaseLanguageModelCallOptions, GoogleAIModelParams, GoogleAIModelRequestParams, GoogleAIToolType, GoogleLLMModelFamily } from "../types.js";
 export declare function copyAIModelParams(params: GoogleAIModelParams | undefined, options: GoogleAIBaseLanguageModelCallOptions | undefined): GoogleAIModelRequestParams;
-export declare function convertToGeminiTools(structuredTools: (StructuredToolInterface | Record<string, unknown> | ToolDefinition | RunnableToolLike)[]): GeminiTool[];
+export declare function convertToGeminiTools(tools: GoogleAIToolType[]): GeminiTool[];
 export declare function copyAIModelParamsInto(params: GoogleAIModelParams | undefined, options: GoogleAIBaseLanguageModelCallOptions | undefined, target: GoogleAIModelParams): GoogleAIModelRequestParams;
 export declare function modelToFamily(modelName: string | undefined): GoogleLLMModelFamily;
 export declare function validateModelParams(params: GoogleAIModelParams | undefined): void;

package/dist/utils/common.js

@@ -1,5 +1,5 @@
-import { isOpenAITool, } from "@langchain/core/language_models/base";
-import { isStructuredTool } from "@langchain/core/utils/function_calling";
+import { isOpenAITool } from "@langchain/core/language_models/base";
+import { isLangChainTool } from "@langchain/core/utils/function_calling";
 import { isModelGemini, validateGeminiParams } from "./gemini.js";
 import { jsonSchemaToGeminiParameters, zodToGeminiParameters, } from "./zod_to_gemini_parameters.js";
 export function copyAIModelParams(params, options) {
@@ -32,35 +32,35 @@ function processToolChoice(toolChoice, allowedFunctionNames) {
     }
     throw new Error("Object inputs for tool_choice not supported.");
 }
-export function convertToGeminiTools(structuredTools) {
-    const tools = [
+export function convertToGeminiTools(tools) {
+    const geminiTools = [
         {
             functionDeclarations: [],
         },
     ];
-    structuredTools.forEach((tool) => {
+    tools.forEach((tool) => {
         if ("functionDeclarations" in tool &&
             Array.isArray(tool.functionDeclarations)) {
             const funcs = tool.functionDeclarations;
-            tools[0].functionDeclarations?.push(...funcs);
+            geminiTools[0].functionDeclarations?.push(...funcs);
         }
-        else if (isStructuredTool(tool)) {
+        else if (isLangChainTool(tool)) {
             const jsonSchema = zodToGeminiParameters(tool.schema);
-            tools[0].functionDeclarations?.push({
+            geminiTools[0].functionDeclarations?.push({
                 name: tool.name,
-                description: tool.description,
+                description: tool.description ?? `A function available to call.`,
                 parameters: jsonSchema,
             });
         }
         else if (isOpenAITool(tool)) {
-            tools[0].functionDeclarations?.push({
+            geminiTools[0].functionDeclarations?.push({
                 name: tool.function.name,
                 description: tool.function.description ?? `A function available to call.`,
                 parameters: jsonSchemaToGeminiParameters(tool.function.parameters),
             });
         }
     });
-    return tools;
+    return geminiTools;
 }
 export function copyAIModelParamsInto(params, options, target) {
     const ret = target || {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/google-common",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "Core types and classes for Google services.",
   "type": "module",
   "engines": {
@@ -40,7 +40,7 @@
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@langchain/core": ">=0.2.16 <0.3.0",
+    "@langchain/core": ">=0.2.21 <0.3.0",
     "uuid": "^10.0.0",
     "zod-to-json-schema": "^3.22.4"
   },
@@ -63,7 +63,7 @@
     "jest": "^29.5.0",
     "jest-environment-node": "^29.6.4",
     "prettier": "^2.8.3",
-    "release-it": "^15.10.1",
+    "release-it": "^17.6.0",
     "rollup": "^4.5.2",
     "ts-jest": "^29.1.0",
     "typescript": "<5.2.0",