@langchain/google-common 0.0.21 → 0.0.23

package/dist/chat_models.cjs

@@ -5,10 +5,9 @@ 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 base_1 = require("@langchain/core/language_models/base");
 const runnables_1 = require("@langchain/core/runnables");
 const openai_tools_1 = require("@langchain/core/output_parsers/openai_tools");
-const function_calling_1 = require("@langchain/core/utils/function_calling");
+const stream_1 = require("@langchain/core/utils/stream");
 const common_js_1 = require("./utils/common.cjs");
 const connection_js_1 = require("./connection.cjs");
 const gemini_js_1 = require("./utils/gemini.cjs");
@@ -58,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) {
@@ -85,31 +97,6 @@ class ChatConnection extends connection_js_1.AbstractGoogleLLMConnection {
         return ret;
     }
 }
-function convertToGeminiTools(structuredTools) {
-    return [
-        {
-            functionDeclarations: structuredTools.map((structuredTool) => {
-                if ((0, function_calling_1.isStructuredTool)(structuredTool)) {
-                    const jsonSchema = (0, zod_to_gemini_parameters_js_1.zodToGeminiParameters)(structuredTool.schema);
-                    return {
-                        name: structuredTool.name,
-                        description: structuredTool.description,
-                        parameters: jsonSchema,
-                    };
-                }
-                if ((0, base_1.isOpenAITool)(structuredTool)) {
-                    return {
-                        name: structuredTool.function.name,
-                        description: structuredTool.function.description ??
-                            `A function available to call.`,
-                        parameters: (0, zod_to_gemini_parameters_js_1.jsonSchemaToGeminiParameters)(structuredTool.function.parameters),
-                    };
-                }
-                return structuredTool;
-            }),
-        },
-    ];
-}
 /**
  * Integration with a chat model.
  */
@@ -199,6 +186,12 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
             writable: true,
             value: true
         });
+        Object.defineProperty(this, "streaming", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "connection", {
             enumerable: true,
             configurable: true,
@@ -252,7 +245,7 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
         return this.connection.platform;
     }
     bindTools(tools, kwargs) {
-        return this.bind({ tools: convertToGeminiTools(tools), ...kwargs });
+        return this.bind({ tools: (0, common_js_1.convertToGeminiTools)(tools), ...kwargs });
     }
     // Replace
     _llmType() {
@@ -264,13 +257,27 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
     invocationParams(options) {
         return (0, common_js_1.copyAIModelParams)(this, options);
     }
-    async _generate(messages, options, _runManager) {
+    async _generate(messages, options, runManager) {
         const parameters = this.invocationParams(options);
+        if (this.streaming) {
+            const stream = this._streamResponseChunks(messages, options, runManager);
+            let finalChunk = null;
+            for await (const chunk of stream) {
+                finalChunk = !finalChunk ? chunk : (0, stream_1.concat)(finalChunk, chunk);
+            }
+            if (!finalChunk) {
+                throw new Error("No chunks were returned from the stream.");
+            }
+            return {
+                generations: [finalChunk],
+            };
+        }
         const response = await this.connection.request(messages, parameters, options);
         const ret = (0, gemini_js_1.safeResponseToChatResult)(response, this.safetyHandler);
+        await runManager?.handleLLMNewToken(ret.generations[0].text);
         return ret;
     }
-    async *_streamResponseChunks(_messages, options, _runManager) {
+    async *_streamResponseChunks(_messages, options, runManager) {
         // Make the call as a streaming request
         const parameters = this.invocationParams(options);
         const response = await this.streamedConnection.request(_messages, parameters, options);
@@ -303,6 +310,7 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
                     }),
                 });
             yield chunk;
+            await runManager?.handleLLMNewToken(chunk.text);
         }
     }
     /** @ignore */

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);
@@ -45,6 +44,7 @@ export declare abstract class ChatGoogleBase<AuthOptions> extends BaseChatModel<
     convertSystemMessageToHumanContent: boolean | undefined;
     safetyHandler: GoogleAISafetyHandler;
     streamUsage: boolean;
+    streaming: boolean;
     protected connection: ChatConnection<AuthOptions>;
     protected streamedConnection: ChatConnection<AuthOptions>;
     constructor(fields?: ChatGoogleBaseInput<AuthOptions>);
@@ -55,14 +55,14 @@ 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
      */
     invocationParams(options?: this["ParsedCallOptions"]): import("./types.js").GoogleAIModelRequestParams;
-    _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], _runManager: CallbackManagerForLLMRun | undefined): Promise<ChatResult>;
-    _streamResponseChunks(_messages: BaseMessage[], options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager: CallbackManagerForLLMRun | undefined): Promise<ChatResult>;
+    _streamResponseChunks(_messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
     /** @ignore */
     _combineLLMOutput(): never[];
     withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;

package/dist/chat_models.js

@@ -2,16 +2,15 @@ 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 { isOpenAITool, } from "@langchain/core/language_models/base";
 import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnables";
 import { JsonOutputKeyToolsParser } from "@langchain/core/output_parsers/openai_tools";
-import { isStructuredTool } from "@langchain/core/utils/function_calling";
-import { copyAIModelParams, copyAndValidateModelParamsInto, } from "./utils/common.js";
+import { concat } from "@langchain/core/utils/stream";
+import { convertToGeminiTools, copyAIModelParams, copyAndValidateModelParamsInto, } from "./utils/common.js";
 import { AbstractGoogleLLMConnection } from "./connection.js";
 import { baseMessageToContent, safeResponseToChatGeneration, safeResponseToChatResult, DefaultGeminiSafetyHandler, } from "./utils/gemini.js";
 import { ApiKeyGoogleAuth } from "./auth.js";
 import { ensureParams } from "./utils/failed_handler.js";
-import { jsonSchemaToGeminiParameters, zodToGeminiParameters, } from "./utils/zod_to_gemini_parameters.js";
+import { zodToGeminiParameters } from "./utils/zod_to_gemini_parameters.js";
 class ChatConnection extends AbstractGoogleLLMConnection {
     constructor(fields, caller, client, streaming) {
         super(fields, caller, client, streaming);
@@ -55,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) {
@@ -82,31 +94,6 @@ class ChatConnection extends AbstractGoogleLLMConnection {
         return ret;
     }
 }
-function convertToGeminiTools(structuredTools) {
-    return [
-        {
-            functionDeclarations: structuredTools.map((structuredTool) => {
-                if (isStructuredTool(structuredTool)) {
-                    const jsonSchema = zodToGeminiParameters(structuredTool.schema);
-                    return {
-                        name: structuredTool.name,
-                        description: structuredTool.description,
-                        parameters: jsonSchema,
-                    };
-                }
-                if (isOpenAITool(structuredTool)) {
-                    return {
-                        name: structuredTool.function.name,
-                        description: structuredTool.function.description ??
-                            `A function available to call.`,
-                        parameters: jsonSchemaToGeminiParameters(structuredTool.function.parameters),
-                    };
-                }
-                return structuredTool;
-            }),
-        },
-    ];
-}
 /**
  * Integration with a chat model.
  */
@@ -196,6 +183,12 @@ export class ChatGoogleBase extends BaseChatModel {
             writable: true,
             value: true
         });
+        Object.defineProperty(this, "streaming", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "connection", {
             enumerable: true,
             configurable: true,
@@ -261,13 +254,27 @@ export class ChatGoogleBase extends BaseChatModel {
     invocationParams(options) {
         return copyAIModelParams(this, options);
     }
-    async _generate(messages, options, _runManager) {
+    async _generate(messages, options, runManager) {
         const parameters = this.invocationParams(options);
+        if (this.streaming) {
+            const stream = this._streamResponseChunks(messages, options, runManager);
+            let finalChunk = null;
+            for await (const chunk of stream) {
+                finalChunk = !finalChunk ? chunk : concat(finalChunk, chunk);
+            }
+            if (!finalChunk) {
+                throw new Error("No chunks were returned from the stream.");
+            }
+            return {
+                generations: [finalChunk],
+            };
+        }
         const response = await this.connection.request(messages, parameters, options);
         const ret = safeResponseToChatResult(response, this.safetyHandler);
+        await runManager?.handleLLMNewToken(ret.generations[0].text);
         return ret;
     }
-    async *_streamResponseChunks(_messages, options, _runManager) {
+    async *_streamResponseChunks(_messages, options, runManager) {
         // Make the call as a streaming request
         const parameters = this.invocationParams(options);
         const response = await this.streamedConnection.request(_messages, parameters, options);
@@ -300,6 +307,7 @@ export class ChatGoogleBase extends BaseChatModel {
                     }),
                 });
             yield chunk;
+            await runManager?.handleLLMNewToken(chunk.text);
         }
     }
     /** @ignore */

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,20 +242,34 @@ 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;
         }
     }
+    formatToolConfig(parameters) {
+        if (!parameters.tool_choice || typeof parameters.tool_choice !== "string") {
+            return undefined;
+        }
+        return {
+            functionCallingConfig: {
+                mode: parameters.tool_choice,
+                allowedFunctionNames: parameters.allowed_function_names,
+            },
+        };
+    }
     formatData(input, parameters) {
         const contents = this.formatContents(input, parameters);
         const generationConfig = this.formatGenerationConfig(input, parameters);
         const tools = this.formatTools(input, parameters);
+        const toolConfig = this.formatToolConfig(parameters);
         const safetySettings = this.formatSafetySettings(input, parameters);
         const systemInstruction = this.formatSystemInstruction(input, parameters);
         const ret = {
@@ -269,6 +279,9 @@ class AbstractGoogleLLMConnection extends GoogleAIConnection {
         if (tools && tools.length) {
             ret.tools = tools;
         }
+        if (toolConfig) {
+            ret.toolConfig = toolConfig;
+        }
         if (safetySettings && safetySettings.length) {
             ret.safetySettings = safetySettings;
         }

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> {
@@ -49,9 +49,9 @@ export declare abstract class AbstractGoogleLLMConnection<MessageType, AuthOptio
     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,20 +236,34 @@ 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;
         }
     }
+    formatToolConfig(parameters) {
+        if (!parameters.tool_choice || typeof parameters.tool_choice !== "string") {
+            return undefined;
+        }
+        return {
+            functionCallingConfig: {
+                mode: parameters.tool_choice,
+                allowedFunctionNames: parameters.allowed_function_names,
+            },
+        };
+    }
     formatData(input, parameters) {
         const contents = this.formatContents(input, parameters);
         const generationConfig = this.formatGenerationConfig(input, parameters);
         const tools = this.formatTools(input, parameters);
+        const toolConfig = this.formatToolConfig(parameters);
         const safetySettings = this.formatSafetySettings(input, parameters);
         const systemInstruction = this.formatSystemInstruction(input, parameters);
         const ret = {
@@ -263,6 +273,9 @@ export class AbstractGoogleLLMConnection extends GoogleAIConnection {
         if (tools && tools.length) {
             ret.tools = tools;
         }
+        if (toolConfig) {
+            ret.toolConfig = toolConfig;
+        }
         if (safetySettings && safetySettings.length) {
             ret.safetySettings = safetySettings;
         }

package/dist/types.d.ts

@@ -1,6 +1,5 @@
 import type { BaseLLMParams } from "@langchain/core/language_models/llms";
-import { BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
-import { StructuredToolInterface } from "@langchain/core/tools";
+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 {
@@ -85,16 +85,40 @@ export interface GoogleAIModelParams {
      * @default "text/plain"
      */
     responseMimeType?: GoogleAIResponseMimeType;
+    /**
+     * Whether or not to stream.
+     * @default false
+     */
+    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.
+     *
+     * | Mode     |	Description                                                                                                                                             |
+     * |----------|---------------------------------------------------------------------------------------------------------------------------------------------------------|
+     * | "auto"	  | The default model behavior. The model decides whether to predict a function call or a natural language response.                                        |
+     * | "any"	  | The model must predict only function calls. To limit the model to a subset of functions, define the allowed function names in `allowed_function_names`. |
+     * | "none"	  | The model must not predict function calls. This behavior is equivalent to a model request without any associated function declarations.                 |
+     * | string   | The string value must be one of the function names. This will force the model to predict the specified function call.                                   |
+     *
+     * The tool configuration's "any" mode ("forced function calling") is supported for Gemini 1.5 Pro models only.
+     */
+    tool_choice?: string | "auto" | "any" | "none" | Record<string, any>;
+    /**
+     * Allowed functions to call when the mode is "any".
+     * If empty, any one of the provided functions are called.
+     */
+    allowed_function_names?: string[];
 }
 export interface GoogleAIBaseLLMInput<AuthOptions> extends BaseLLMParams, GoogleConnectionParams<AuthOptions>, GoogleAIModelParams, GoogleAISafetyParams {
 }
-export interface GoogleAIBaseLanguageModelCallOptions extends BaseLanguageModelCallOptions, GoogleAIModelRequestParams, GoogleAISafetyParams {
+export interface GoogleAIBaseLanguageModelCallOptions extends BaseChatModelCallOptions, GoogleAIModelRequestParams, GoogleAISafetyParams {
     /**
      * Whether or not to include usage data, like token counts
      * in the streamed response chunks.
@@ -183,6 +207,12 @@ export interface GeminiRequest {
     contents?: GeminiContent[];
     systemInstruction?: GeminiContent;
     tools?: GeminiTool[];
+    toolConfig?: {
+        functionCallingConfig: {
+            mode: "auto" | "any" | "none";
+            allowedFunctionNames?: string[];
+        };
+    };
     safetySettings?: GeminiSafetySetting[];
     generationConfig?: GeminiGenerationConfig;
 }

package/dist/utils/common.cjs

@@ -1,11 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.copyAndValidateModelParamsInto = exports.validateModelParams = exports.modelToFamily = exports.copyAIModelParamsInto = exports.copyAIModelParams = void 0;
+exports.copyAndValidateModelParamsInto = exports.validateModelParams = exports.modelToFamily = exports.copyAIModelParamsInto = exports.convertToGeminiTools = exports.copyAIModelParams = void 0;
+const base_1 = require("@langchain/core/language_models/base");
+const function_calling_1 = require("@langchain/core/utils/function_calling");
 const gemini_js_1 = require("./gemini.cjs");
+const zod_to_gemini_parameters_js_1 = require("./zod_to_gemini_parameters.cjs");
 function copyAIModelParams(params, options) {
     return copyAIModelParamsInto(params, options, {});
 }
 exports.copyAIModelParams = copyAIModelParams;
+function processToolChoice(toolChoice, allowedFunctionNames) {
+    if (!toolChoice) {
+        if (allowedFunctionNames) {
+            // Allowed func names is passed, return 'any' so it forces the model to use a tool.
+            return {
+                tool_choice: "any",
+                allowed_function_names: allowedFunctionNames,
+            };
+        }
+        return undefined;
+    }
+    if (toolChoice === "any" || toolChoice === "auto" || toolChoice === "none") {
+        return {
+            tool_choice: toolChoice,
+            allowed_function_names: allowedFunctionNames,
+        };
+    }
+    if (typeof toolChoice === "string") {
+        // String representing the function name.
+        // Return any to force the model to predict the specified function call.
+        return {
+            tool_choice: "any",
+            allowed_function_names: [...(allowedFunctionNames ?? []), toolChoice],
+        };
+    }
+    throw new Error("Object inputs for tool_choice not supported.");
+}
+function convertToGeminiTools(tools) {
+    const geminiTools = [
+        {
+            functionDeclarations: [],
+        },
+    ];
+    tools.forEach((tool) => {
+        if ("functionDeclarations" in tool &&
+            Array.isArray(tool.functionDeclarations)) {
+            const funcs = tool.functionDeclarations;
+            geminiTools[0].functionDeclarations?.push(...funcs);
+        }
+        else if ((0, function_calling_1.isLangChainTool)(tool)) {
+            const jsonSchema = (0, zod_to_gemini_parameters_js_1.zodToGeminiParameters)(tool.schema);
+            geminiTools[0].functionDeclarations?.push({
+                name: tool.name,
+                description: tool.description ?? `A function available to call.`,
+                parameters: jsonSchema,
+            });
+        }
+        else if ((0, base_1.isOpenAITool)(tool)) {
+            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 geminiTools;
+}
+exports.convertToGeminiTools = convertToGeminiTools;
 function copyAIModelParamsInto(params, options, target) {
     const ret = target || {};
     const model = options?.model ?? params?.model ?? target.model;
@@ -32,59 +93,17 @@ function copyAIModelParamsInto(params, options, target) {
         options?.responseMimeType ??
             params?.responseMimeType ??
             target?.responseMimeType;
-    ret.tools = options?.tools;
-    // Ensure tools are formatted properly for Gemini
-    const geminiTools = options?.tools
-        ?.map((tool) => {
-        if ("function" in tool &&
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            "parameters" in tool.function) {
-            // Tool is in OpenAI format. Convert to Gemini then return.
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const castTool = tool.function;
-            const cleanedParameters = castTool.parameters;
-            if ("$schema" in cleanedParameters) {
-                delete cleanedParameters.$schema;
-            }
-            if ("additionalProperties" in cleanedParameters) {
-                delete cleanedParameters.additionalProperties;
-            }
-            const toolInGeminiFormat = {
-                functionDeclarations: [
-                    {
-                        name: castTool.name,
-                        description: castTool.description,
-                        parameters: cleanedParameters,
-                    },
-                ],
-            };
-            return toolInGeminiFormat;
-        }
-        else if ("functionDeclarations" in tool) {
-            return tool;
-        }
-        else {
-            return null;
-        }
-    })
-        .filter((tool) => tool !== null);
-    const structuredOutputTools = options?.tools
-        ?.map((tool) => {
-        if ("lc_namespace" in tool) {
-            return tool;
-        }
-        else {
-            return null;
-        }
-    })
-        .filter((tool) => tool !== null);
-    if (structuredOutputTools &&
-        structuredOutputTools.length > 0 &&
-        geminiTools &&
-        geminiTools.length > 0) {
-        throw new Error(`Cannot mix structured tools with Gemini tools.\nReceived ${structuredOutputTools.length} structured tools and ${geminiTools.length} Gemini tools.`);
+    ret.streaming = options?.streaming ?? params?.streaming ?? target?.streaming;
+    const toolChoice = processToolChoice(options?.tool_choice, options?.allowed_function_names);
+    if (toolChoice) {
+        ret.tool_choice = toolChoice.tool_choice;
+        ret.allowed_function_names = toolChoice.allowed_function_names;
+    }
+    const tools = options?.tools;
+    if (tools) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ret.tools = convertToGeminiTools(tools);
     }
-    ret.tools = geminiTools ?? structuredOutputTools;
     return ret;
 }
 exports.copyAIModelParamsInto = copyAIModelParamsInto;

package/dist/utils/common.d.ts

@@ -1,5 +1,6 @@
-import type { 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(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,7 +1,67 @@
+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) {
     return copyAIModelParamsInto(params, options, {});
 }
+function processToolChoice(toolChoice, allowedFunctionNames) {
+    if (!toolChoice) {
+        if (allowedFunctionNames) {
+            // Allowed func names is passed, return 'any' so it forces the model to use a tool.
+            return {
+                tool_choice: "any",
+                allowed_function_names: allowedFunctionNames,
+            };
+        }
+        return undefined;
+    }
+    if (toolChoice === "any" || toolChoice === "auto" || toolChoice === "none") {
+        return {
+            tool_choice: toolChoice,
+            allowed_function_names: allowedFunctionNames,
+        };
+    }
+    if (typeof toolChoice === "string") {
+        // String representing the function name.
+        // Return any to force the model to predict the specified function call.
+        return {
+            tool_choice: "any",
+            allowed_function_names: [...(allowedFunctionNames ?? []), toolChoice],
+        };
+    }
+    throw new Error("Object inputs for tool_choice not supported.");
+}
+export function convertToGeminiTools(tools) {
+    const geminiTools = [
+        {
+            functionDeclarations: [],
+        },
+    ];
+    tools.forEach((tool) => {
+        if ("functionDeclarations" in tool &&
+            Array.isArray(tool.functionDeclarations)) {
+            const funcs = tool.functionDeclarations;
+            geminiTools[0].functionDeclarations?.push(...funcs);
+        }
+        else if (isLangChainTool(tool)) {
+            const jsonSchema = zodToGeminiParameters(tool.schema);
+            geminiTools[0].functionDeclarations?.push({
+                name: tool.name,
+                description: tool.description ?? `A function available to call.`,
+                parameters: jsonSchema,
+            });
+        }
+        else if (isOpenAITool(tool)) {
+            geminiTools[0].functionDeclarations?.push({
+                name: tool.function.name,
+                description: tool.function.description ?? `A function available to call.`,
+                parameters: jsonSchemaToGeminiParameters(tool.function.parameters),
+            });
+        }
+    });
+    return geminiTools;
+}
 export function copyAIModelParamsInto(params, options, target) {
     const ret = target || {};
     const model = options?.model ?? params?.model ?? target.model;
@@ -28,59 +88,17 @@ export function copyAIModelParamsInto(params, options, target) {
         options?.responseMimeType ??
             params?.responseMimeType ??
             target?.responseMimeType;
-    ret.tools = options?.tools;
-    // Ensure tools are formatted properly for Gemini
-    const geminiTools = options?.tools
-        ?.map((tool) => {
-        if ("function" in tool &&
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            "parameters" in tool.function) {
-            // Tool is in OpenAI format. Convert to Gemini then return.
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const castTool = tool.function;
-            const cleanedParameters = castTool.parameters;
-            if ("$schema" in cleanedParameters) {
-                delete cleanedParameters.$schema;
-            }
-            if ("additionalProperties" in cleanedParameters) {
-                delete cleanedParameters.additionalProperties;
-            }
-            const toolInGeminiFormat = {
-                functionDeclarations: [
-                    {
-                        name: castTool.name,
-                        description: castTool.description,
-                        parameters: cleanedParameters,
-                    },
-                ],
-            };
-            return toolInGeminiFormat;
-        }
-        else if ("functionDeclarations" in tool) {
-            return tool;
-        }
-        else {
-            return null;
-        }
-    })
-        .filter((tool) => tool !== null);
-    const structuredOutputTools = options?.tools
-        ?.map((tool) => {
-        if ("lc_namespace" in tool) {
-            return tool;
-        }
-        else {
-            return null;
-        }
-    })
-        .filter((tool) => tool !== null);
-    if (structuredOutputTools &&
-        structuredOutputTools.length > 0 &&
-        geminiTools &&
-        geminiTools.length > 0) {
-        throw new Error(`Cannot mix structured tools with Gemini tools.\nReceived ${structuredOutputTools.length} structured tools and ${geminiTools.length} Gemini tools.`);
+    ret.streaming = options?.streaming ?? params?.streaming ?? target?.streaming;
+    const toolChoice = processToolChoice(options?.tool_choice, options?.allowed_function_names);
+    if (toolChoice) {
+        ret.tool_choice = toolChoice.tool_choice;
+        ret.allowed_function_names = toolChoice.allowed_function_names;
+    }
+    const tools = options?.tools;
+    if (tools) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ret.tools = convertToGeminiTools(tools);
     }
-    ret.tools = geminiTools ?? structuredOutputTools;
     return ret;
 }
 export function modelToFamily(modelName) {

package/dist/utils/gemini.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageGeminiSafetyHandler = exports.DefaultGeminiSafetyHandler = exports.isModelGemini = exports.validateGeminiParams = exports.safeResponseToChatResult = exports.responseToChatResult = exports.safeResponseToBaseMessage = exports.responseToBaseMessage = exports.partsToBaseMessageFields = exports.responseToBaseMessageFields = exports.responseToChatGenerations = exports.partToChatGeneration = exports.partToMessageChunk = exports.chunkToString = exports.safeResponseToChatGeneration = exports.responseToChatGeneration = exports.safeResponseToGeneration = exports.responseToGeneration = exports.responseToGenerationInfo = exports.safeResponseToString = exports.responseToString = exports.partToText = exports.responseToParts = exports.responseToGenerateContentResponseData = exports.toolsRawToTools = exports.partsToToolsRaw = exports.partsToMessageContent = exports.baseMessageToContent = exports.messageContentToParts = void 0;
+exports.MessageGeminiSafetyHandler = exports.DefaultGeminiSafetyHandler = exports.isModelGemini = exports.validateGeminiParams = exports.safeResponseToChatResult = exports.responseToChatResult = exports.safeResponseToBaseMessage = exports.responseToBaseMessage = exports.partsToBaseMessageChunkFields = exports.responseToBaseMessageFields = exports.responseToChatGenerations = exports.partToChatGeneration = exports.partToMessageChunk = exports.chunkToString = exports.safeResponseToChatGeneration = exports.responseToChatGeneration = exports.safeResponseToGeneration = exports.responseToGeneration = exports.responseToGenerationInfo = exports.safeResponseToString = exports.responseToString = exports.partToText = exports.responseToParts = exports.responseToGenerateContentResponseData = exports.toolsRawToTools = exports.partsToToolsRaw = exports.partsToMessageContent = exports.baseMessageToContent = exports.messageContentToParts = void 0;
 const uuid_1 = require("uuid");
 const messages_1 = require("@langchain/core/messages");
 const outputs_1 = require("@langchain/core/outputs");
@@ -445,7 +445,7 @@ function chunkToString(chunk) {
 }
 exports.chunkToString = chunkToString;
 function partToMessageChunk(part) {
-    const fields = partsToBaseMessageFields([part]);
+    const fields = partsToBaseMessageChunkFields([part]);
     if (typeof fields.content === "string") {
         return new messages_1.AIMessageChunk(fields);
     }
@@ -510,12 +510,13 @@ function responseToChatGenerations(response) {
 exports.responseToChatGenerations = responseToChatGenerations;
 function responseToBaseMessageFields(response) {
     const parts = responseToParts(response);
-    return partsToBaseMessageFields(parts);
+    return partsToBaseMessageChunkFields(parts);
 }
 exports.responseToBaseMessageFields = responseToBaseMessageFields;
-function partsToBaseMessageFields(parts) {
+function partsToBaseMessageChunkFields(parts) {
     const fields = {
         content: partsToMessageContent(parts),
+        tool_call_chunks: [],
         tool_calls: [],
         invalid_tool_calls: [],
     };
@@ -523,6 +524,12 @@ function partsToBaseMessageFields(parts) {
     if (rawTools.length > 0) {
         const tools = toolsRawToTools(rawTools);
         for (const tool of tools) {
+            fields.tool_call_chunks?.push({
+                name: tool.function.name,
+                args: tool.function.arguments,
+                id: tool.id,
+                type: "tool_call_chunk",
+            });
             try {
                 fields.tool_calls?.push({
                     name: tool.function.name,
@@ -535,7 +542,7 @@ function partsToBaseMessageFields(parts) {
             catch (e) {
                 fields.invalid_tool_calls?.push({
                     name: tool.function.name,
-                    args: JSON.parse(tool.function.arguments),
+                    args: tool.function.arguments,
                     id: tool.id,
                     error: e.message,
                     type: "invalid_tool_call",
@@ -548,7 +555,7 @@ function partsToBaseMessageFields(parts) {
     }
     return fields;
 }
-exports.partsToBaseMessageFields = partsToBaseMessageFields;
+exports.partsToBaseMessageChunkFields = partsToBaseMessageChunkFields;
 function responseToBaseMessage(response) {
     const fields = responseToBaseMessageFields(response);
     return new messages_1.AIMessage(fields);

package/dist/utils/gemini.d.ts

@@ -1,4 +1,4 @@
-import { AIMessageFields, BaseMessage, BaseMessageChunk, BaseMessageFields, MessageContent } from "@langchain/core/messages";
+import { AIMessageChunkFields, BaseMessage, BaseMessageChunk, BaseMessageFields, MessageContent } from "@langchain/core/messages";
 import { ChatGeneration, ChatGenerationChunk, ChatResult, Generation } from "@langchain/core/outputs";
 import type { GoogleLLMResponse, GoogleAIModelParams, GeminiPart, GeminiContent, GenerateContentResponseData, GoogleAISafetyHandler } from "../types.js";
 export declare function messageContentToParts(content: MessageContent): GeminiPart[];
@@ -57,7 +57,7 @@ export declare function partToMessageChunk(part: GeminiPart): BaseMessageChunk;
 export declare function partToChatGeneration(part: GeminiPart): ChatGeneration;
 export declare function responseToChatGenerations(response: GoogleLLMResponse): ChatGeneration[];
 export declare function responseToBaseMessageFields(response: GoogleLLMResponse): BaseMessageFields;
-export declare function partsToBaseMessageFields(parts: GeminiPart[]): AIMessageFields;
+export declare function partsToBaseMessageChunkFields(parts: GeminiPart[]): AIMessageChunkFields;
 export declare function responseToBaseMessage(response: GoogleLLMResponse): BaseMessage;
 export declare function safeResponseToBaseMessage(response: GoogleLLMResponse, safetyHandler: GoogleAISafetyHandler): BaseMessage;
 export declare function responseToChatResult(response: GoogleLLMResponse): ChatResult;

package/dist/utils/gemini.js

@@ -426,7 +426,7 @@ export function chunkToString(chunk) {
     }
 }
 export function partToMessageChunk(part) {
-    const fields = partsToBaseMessageFields([part]);
+    const fields = partsToBaseMessageChunkFields([part]);
     if (typeof fields.content === "string") {
         return new AIMessageChunk(fields);
     }
@@ -488,11 +488,12 @@ export function responseToChatGenerations(response) {
 }
 export function responseToBaseMessageFields(response) {
     const parts = responseToParts(response);
-    return partsToBaseMessageFields(parts);
+    return partsToBaseMessageChunkFields(parts);
 }
-export function partsToBaseMessageFields(parts) {
+export function partsToBaseMessageChunkFields(parts) {
     const fields = {
         content: partsToMessageContent(parts),
+        tool_call_chunks: [],
         tool_calls: [],
         invalid_tool_calls: [],
     };
@@ -500,6 +501,12 @@ export function partsToBaseMessageFields(parts) {
     if (rawTools.length > 0) {
         const tools = toolsRawToTools(rawTools);
         for (const tool of tools) {
+            fields.tool_call_chunks?.push({
+                name: tool.function.name,
+                args: tool.function.arguments,
+                id: tool.id,
+                type: "tool_call_chunk",
+            });
             try {
                 fields.tool_calls?.push({
                     name: tool.function.name,
@@ -512,7 +519,7 @@ export function partsToBaseMessageFields(parts) {
             catch (e) {
                 fields.invalid_tool_calls?.push({
                     name: tool.function.name,
-                    args: JSON.parse(tool.function.arguments),
+                    args: tool.function.arguments,
                     id: tool.id,
                     error: e.message,
                     type: "invalid_tool_call",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/google-common",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "description": "Core types and classes for Google services.",
   "type": "module",
   "engines": {
@@ -15,7 +15,7 @@
   "homepage": "https://github.com/langchain-ai/langchainjs/tree/main/libs/langchain-google-common/",
   "scripts": {
     "build": "yarn turbo:command build:internal --filter=@langchain/google-common",
-    "build:internal": "yarn lc-build:v2 --create-entrypoints --pre --tree-shaking",
+    "build:internal": "yarn lc_build_v2 --create-entrypoints --pre --tree-shaking",
     "build:deps": "yarn run turbo:command build --filter=@langchain/core",
     "build:esm": "NODE_OPTIONS=--max-old-space-size=4096 tsc --outDir dist/ && rm -rf dist/tests dist/**/tests",
     "build:cjs": "NODE_OPTIONS=--max-old-space-size=4096 tsc --outDir dist-cjs/ -p tsconfig.cjs.json && yarn move-cjs-to-dist && rm -rf dist-cjs",
@@ -40,13 +40,13 @@
   "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"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",
-    "@langchain/scripts": "~0.0.14",
+    "@langchain/scripts": "~0.0.20",
     "@swc/core": "^1.3.90",
     "@swc/jest": "^0.2.29",
     "@tsconfig/recommended": "^1.0.3",
@@ -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",