@langchain/google-common 0.0.21 → 0.0.22

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");
@@ -85,31 +84,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 +173,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 +232,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 +244,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 +297,7 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
                     }),
                 });
             yield chunk;
+            await runManager?.handleLLMNewToken(chunk.text);
         }
     }
     /** @ignore */

package/dist/chat_models.d.ts

@@ -45,6 +45,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>);
@@ -61,8 +62,8 @@ export declare abstract class ChatGoogleBase<AuthOptions> extends BaseChatModel<
      * 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);
@@ -82,31 +81,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 +170,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 +241,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 +294,7 @@ export class ChatGoogleBase extends BaseChatModel {
                     }),
                 });
             yield chunk;
+            await runManager?.handleLLMNewToken(chunk.text);
         }
     }
     /** @ignore */

package/dist/connection.cjs

@@ -256,10 +256,22 @@ class AbstractGoogleLLMConnection extends GoogleAIConnection {
             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 +281,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

@@ -53,5 +53,6 @@ export declare abstract class AbstractGoogleLLMConnection<MessageType, AuthOptio
     structuredToolToFunctionDeclaration(tool: StructuredToolInterface): GeminiFunctionDeclaration;
     structuredToolsToGeminiTools(tools: StructuredToolInterface[]): GeminiTool[];
     formatTools(_input: MessageType, parameters: GoogleAIModelRequestParams): GeminiTool[];
+    formatToolConfig(parameters: GoogleAIModelRequestParams): GeminiRequest["toolConfig"] | undefined;
     formatData(input: MessageType, parameters: GoogleAIModelRequestParams): GeminiRequest;
 }

package/dist/connection.js

@@ -250,10 +250,22 @@ export class AbstractGoogleLLMConnection extends GoogleAIConnection {
             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 +275,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,6 @@
 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 } from "@langchain/core/language_models/chat_models";
 import type { JsonStream } from "./utils/stream.js";
 /**
  * Parameters needed to setup the client connection.
@@ -85,16 +85,39 @@ export interface GoogleAIModelParams {
      * @default "text/plain"
      */
     responseMimeType?: GoogleAIResponseMimeType;
+    /**
+     * Whether or not to stream.
+     * @default false
+     */
+    streaming?: boolean;
 }
 /**
  * The params which can be passed to the API at request time.
  */
 export interface GoogleAIModelRequestParams extends GoogleAIModelParams {
     tools?: StructuredToolInterface[] | GeminiTool[];
+    /**
+     * 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 +206,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(structuredTools) {
+    const tools = [
+        {
+            functionDeclarations: [],
+        },
+    ];
+    structuredTools.forEach((tool) => {
+        if ("functionDeclarations" in tool &&
+            Array.isArray(tool.functionDeclarations)) {
+            const funcs = tool.functionDeclarations;
+            tools[0].functionDeclarations?.push(...funcs);
+        }
+        else if ((0, function_calling_1.isStructuredTool)(tool)) {
+            const jsonSchema = (0, zod_to_gemini_parameters_js_1.zodToGeminiParameters)(tool.schema);
+            tools[0].functionDeclarations?.push({
+                name: tool.name,
+                description: tool.description,
+                parameters: jsonSchema,
+            });
+        }
+        else if ((0, base_1.isOpenAITool)(tool)) {
+            tools[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;
+}
+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,9 @@
-import type { GoogleAIBaseLanguageModelCallOptions, GoogleAIModelParams, GoogleAIModelRequestParams, GoogleLLMModelFamily } from "../types.js";
+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";
 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 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 { isStructuredTool } 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(structuredTools) {
+    const tools = [
+        {
+            functionDeclarations: [],
+        },
+    ];
+    structuredTools.forEach((tool) => {
+        if ("functionDeclarations" in tool &&
+            Array.isArray(tool.functionDeclarations)) {
+            const funcs = tool.functionDeclarations;
+            tools[0].functionDeclarations?.push(...funcs);
+        }
+        else if (isStructuredTool(tool)) {
+            const jsonSchema = zodToGeminiParameters(tool.schema);
+            tools[0].functionDeclarations?.push({
+                name: tool.name,
+                description: tool.description,
+                parameters: jsonSchema,
+            });
+        }
+        else if (isOpenAITool(tool)) {
+            tools[0].functionDeclarations?.push({
+                name: tool.function.name,
+                description: tool.function.description ?? `A function available to call.`,
+                parameters: jsonSchemaToGeminiParameters(tool.function.parameters),
+            });
+        }
+    });
+    return tools;
+}
 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.22",
   "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",
@@ -46,7 +46,7 @@
   },
   "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",