@langchain/google-genai 0.0.15 → 0.0.17

package/dist/chat_models.cjs

@@ -4,7 +4,11 @@ exports.ChatGoogleGenerativeAI = void 0;
 const generative_ai_1 = require("@google/generative-ai");
 const env_1 = require("@langchain/core/utils/env");
 const chat_models_1 = require("@langchain/core/language_models/chat_models");
-const utils_js_1 = require("./utils.cjs");
+const runnables_1 = require("@langchain/core/runnables");
+const types_1 = require("@langchain/core/utils/types");
+const zod_to_genai_parameters_js_1 = require("./utils/zod_to_genai_parameters.cjs");
+const common_js_1 = require("./utils/common.cjs");
+const output_parsers_js_1 = require("./output_parsers.cjs");
 /**
  * A class that wraps the Google Palm chat model.
  * @example
@@ -36,7 +40,7 @@ const utils_js_1 = require("./utils.cjs");
  */
 class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
     static lc_name() {
-        return "googlegenerativeai";
+        return "ChatGoogleGenerativeAI";
     }
     get lc_secrets() {
         return {
@@ -177,13 +181,12 @@ class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
         });
     }
     getLsParams(options) {
-        const params = this.invocationParams(options);
         return {
             ls_provider: "google_genai",
             ls_model_name: this.model,
             ls_model_type: "chat",
-            ls_temperature: params.temperature ?? undefined,
-            ls_max_tokens: params.maxOutputTokens ?? undefined,
+            ls_temperature: this.client.generationConfig.temperature,
+            ls_max_tokens: this.client.generationConfig.maxOutputTokens,
             ls_stop: options.stop,
         };
     }
@@ -193,8 +196,27 @@ class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
     _llmType() {
         return "googlegenerativeai";
     }
+    bindTools(tools, kwargs) {
+        return this.bind({ tools: (0, common_js_1.convertToGenerativeAITools)(tools), ...kwargs });
+    }
+    invocationParams(options) {
+        const tools = options?.tools;
+        if (Array.isArray(tools) &&
+            !tools.some(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (t) => !("lc_namespace" in t))) {
+            // Tools are in StructuredToolInterface format. Convert to GenAI format
+            return {
+                tools: (0, common_js_1.convertToGenerativeAITools)(options?.tools),
+            };
+        }
+        return {
+            tools: options?.tools,
+        };
+    }
     async _generate(messages, options, runManager) {
-        const prompt = (0, utils_js_1.convertBaseMessagesToContent)(messages, this._isMultimodalModel);
+        const prompt = (0, common_js_1.convertBaseMessagesToContent)(messages, this._isMultimodalModel);
+        const parameters = this.invocationParams(options);
         // Handle streaming
         if (this.streaming) {
             const tokenUsage = {};
@@ -218,6 +240,7 @@ class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
             let output;
             try {
                 output = await this.client.generateContent({
+                    ...parameters,
                     contents: prompt,
                 });
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -231,20 +254,22 @@ class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
             }
             return output;
         });
-        const generationResult = (0, utils_js_1.mapGenerateContentResultToChatResult)(res.response);
+        const generationResult = (0, common_js_1.mapGenerateContentResultToChatResult)(res.response);
         await runManager?.handleLLMNewToken(generationResult.generations[0].text ?? "");
         return generationResult;
     }
     async *_streamResponseChunks(messages, options, runManager) {
-        const prompt = (0, utils_js_1.convertBaseMessagesToContent)(messages, this._isMultimodalModel);
+        const prompt = (0, common_js_1.convertBaseMessagesToContent)(messages, this._isMultimodalModel);
+        const parameters = this.invocationParams(options);
         const stream = await this.caller.callWithOptions({ signal: options?.signal }, async () => {
             const { stream } = await this.client.generateContentStream({
+                ...parameters,
                 contents: prompt,
             });
             return stream;
         });
         for await (const response of stream) {
-            const chunk = (0, utils_js_1.convertResponseContentToChatGenerationChunk)(response);
+            const chunk = (0, common_js_1.convertResponseContentToChatGenerationChunk)(response);
             if (!chunk) {
                 continue;
             }
@@ -252,5 +277,88 @@ class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
             await runManager?.handleLLMNewToken(chunk.text ?? "");
         }
     }
+    withStructuredOutput(outputSchema, config) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const schema = outputSchema;
+        const name = config?.name;
+        const method = config?.method;
+        const includeRaw = config?.includeRaw;
+        if (method === "jsonMode") {
+            throw new Error(`ChatGoogleGenerativeAI only supports "functionCalling" as a method.`);
+        }
+        let functionName = name ?? "extract";
+        let outputParser;
+        let tools;
+        if ((0, types_1.isZodSchema)(schema)) {
+            const jsonSchema = (0, zod_to_genai_parameters_js_1.zodToGenerativeAIParameters)(schema);
+            tools = [
+                {
+                    functionDeclarations: [
+                        {
+                            name: functionName,
+                            description: jsonSchema.description ?? "A function available to call.",
+                            parameters: jsonSchema,
+                        },
+                    ],
+                },
+            ];
+            outputParser = new output_parsers_js_1.GoogleGenerativeAIToolsOutputParser({
+                returnSingle: true,
+                keyName: functionName,
+                zodSchema: schema,
+            });
+        }
+        else {
+            let geminiFunctionDefinition;
+            if (typeof schema.name === "string" &&
+                typeof schema.parameters === "object" &&
+                schema.parameters != null) {
+                geminiFunctionDefinition = schema;
+                functionName = schema.name;
+            }
+            else {
+                geminiFunctionDefinition = {
+                    name: functionName,
+                    description: schema.description ?? "",
+                    parameters: schema,
+                };
+            }
+            tools = [
+                {
+                    functionDeclarations: [geminiFunctionDefinition],
+                },
+            ];
+            outputParser = new output_parsers_js_1.GoogleGenerativeAIToolsOutputParser({
+                returnSingle: true,
+                keyName: functionName,
+            });
+        }
+        const llm = this.bind({
+            tools,
+        });
+        if (!includeRaw) {
+            return llm.pipe(outputParser).withConfig({
+                runName: "ChatGoogleGenerativeAIStructuredOutput",
+            });
+        }
+        const parserAssign = runnables_1.RunnablePassthrough.assign({
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            parsed: (input, config) => outputParser.invoke(input.raw, config),
+        });
+        const parserNone = runnables_1.RunnablePassthrough.assign({
+            parsed: () => null,
+        });
+        const parsedWithFallback = parserAssign.withFallbacks({
+            fallbacks: [parserNone],
+        });
+        return runnables_1.RunnableSequence.from([
+            {
+                raw: llm,
+            },
+            parsedWithFallback,
+        ]).withConfig({
+            runName: "StructuredOutputRunnable",
+        });
+    }
 }
 exports.ChatGoogleGenerativeAI = ChatGoogleGenerativeAI;

package/dist/chat_models.d.ts

@@ -1,12 +1,19 @@
-import type { SafetySetting } from "@google/generative-ai";
+import { FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool, GenerateContentRequest, SafetySetting } from "@google/generative-ai";
 import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
-import { BaseMessage } from "@langchain/core/messages";
+import { AIMessageChunk, BaseMessage } from "@langchain/core/messages";
 import { ChatGenerationChunk, ChatResult } from "@langchain/core/outputs";
 import { BaseChatModel, LangSmithParams, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
+import { BaseLanguageModelCallOptions, BaseLanguageModelInput, StructuredOutputMethodOptions } from "@langchain/core/language_models/base";
+import { StructuredToolInterface } from "@langchain/core/tools";
+import { Runnable } from "@langchain/core/runnables";
+import type { z } from "zod";
 export type BaseMessageExamplePair = {
     input: BaseMessage;
     output: BaseMessage;
 };
+export interface GoogleGenerativeAIChatCallOptions extends BaseLanguageModelCallOptions {
+    tools?: StructuredToolInterface[] | GoogleGenerativeAIFunctionDeclarationsTool[];
+}
 /**
  * An interface defining the input to the ChatGoogleGenerativeAI class.
  */
@@ -124,7 +131,7 @@ export interface GoogleGenerativeAIChatInput extends BaseChatModelParams {
  * console.log({ res });
  * ```
  */
-export declare class ChatGoogleGenerativeAI extends BaseChatModel implements GoogleGenerativeAIChatInput {
+export declare class ChatGoogleGenerativeAI extends BaseChatModel<GoogleGenerativeAIChatCallOptions, AIMessageChunk> implements GoogleGenerativeAIChatInput {
     static lc_name(): string;
     lc_serializable: boolean;
     get lc_secrets(): {
@@ -143,9 +150,16 @@ export declare class ChatGoogleGenerativeAI extends BaseChatModel implements Goo
     private client;
     get _isMultimodalModel(): boolean;
     constructor(fields?: GoogleGenerativeAIChatInput);
-    protected getLsParams(options: this["ParsedCallOptions"]): LangSmithParams;
+    getLsParams(options: this["ParsedCallOptions"]): LangSmithParams;
     _combineLLMOutput(): never[];
     _llmType(): string;
+    bindTools(tools: (StructuredToolInterface | Record<string, unknown>)[], kwargs?: Partial<GoogleGenerativeAIChatCallOptions>): Runnable<BaseLanguageModelInput, AIMessageChunk, GoogleGenerativeAIChatCallOptions>;
+    invocationParams(options?: this["ParsedCallOptions"]): Omit<GenerateContentRequest, "contents">;
     _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
     _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+        raw: BaseMessage;
+        parsed: RunOutput;
+    }>;
 }

package/dist/chat_models.js

@@ -1,7 +1,11 @@
 import { GoogleGenerativeAI as GenerativeAI, } from "@google/generative-ai";
 import { getEnvironmentVariable } from "@langchain/core/utils/env";
 import { BaseChatModel, } from "@langchain/core/language_models/chat_models";
-import { convertBaseMessagesToContent, convertResponseContentToChatGenerationChunk, mapGenerateContentResultToChatResult, } from "./utils.js";
+import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnables";
+import { isZodSchema } from "@langchain/core/utils/types";
+import { zodToGenerativeAIParameters } from "./utils/zod_to_genai_parameters.js";
+import { convertBaseMessagesToContent, convertResponseContentToChatGenerationChunk, convertToGenerativeAITools, mapGenerateContentResultToChatResult, } from "./utils/common.js";
+import { GoogleGenerativeAIToolsOutputParser } from "./output_parsers.js";
 /**
  * A class that wraps the Google Palm chat model.
  * @example
@@ -33,7 +37,7 @@ import { convertBaseMessagesToContent, convertResponseContentToChatGenerationChu
  */
 export class ChatGoogleGenerativeAI extends BaseChatModel {
     static lc_name() {
-        return "googlegenerativeai";
+        return "ChatGoogleGenerativeAI";
     }
     get lc_secrets() {
         return {
@@ -174,13 +178,12 @@ export class ChatGoogleGenerativeAI extends BaseChatModel {
         });
     }
     getLsParams(options) {
-        const params = this.invocationParams(options);
         return {
             ls_provider: "google_genai",
             ls_model_name: this.model,
             ls_model_type: "chat",
-            ls_temperature: params.temperature ?? undefined,
-            ls_max_tokens: params.maxOutputTokens ?? undefined,
+            ls_temperature: this.client.generationConfig.temperature,
+            ls_max_tokens: this.client.generationConfig.maxOutputTokens,
             ls_stop: options.stop,
         };
     }
@@ -190,8 +193,27 @@ export class ChatGoogleGenerativeAI extends BaseChatModel {
     _llmType() {
         return "googlegenerativeai";
     }
+    bindTools(tools, kwargs) {
+        return this.bind({ tools: convertToGenerativeAITools(tools), ...kwargs });
+    }
+    invocationParams(options) {
+        const tools = options?.tools;
+        if (Array.isArray(tools) &&
+            !tools.some(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (t) => !("lc_namespace" in t))) {
+            // Tools are in StructuredToolInterface format. Convert to GenAI format
+            return {
+                tools: convertToGenerativeAITools(options?.tools),
+            };
+        }
+        return {
+            tools: options?.tools,
+        };
+    }
     async _generate(messages, options, runManager) {
         const prompt = convertBaseMessagesToContent(messages, this._isMultimodalModel);
+        const parameters = this.invocationParams(options);
         // Handle streaming
         if (this.streaming) {
             const tokenUsage = {};
@@ -215,6 +237,7 @@ export class ChatGoogleGenerativeAI extends BaseChatModel {
             let output;
             try {
                 output = await this.client.generateContent({
+                    ...parameters,
                     contents: prompt,
                 });
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -234,8 +257,10 @@ export class ChatGoogleGenerativeAI extends BaseChatModel {
     }
     async *_streamResponseChunks(messages, options, runManager) {
         const prompt = convertBaseMessagesToContent(messages, this._isMultimodalModel);
+        const parameters = this.invocationParams(options);
         const stream = await this.caller.callWithOptions({ signal: options?.signal }, async () => {
             const { stream } = await this.client.generateContentStream({
+                ...parameters,
                 contents: prompt,
             });
             return stream;
@@ -249,4 +274,87 @@ export class ChatGoogleGenerativeAI extends BaseChatModel {
             await runManager?.handleLLMNewToken(chunk.text ?? "");
         }
     }
+    withStructuredOutput(outputSchema, config) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const schema = outputSchema;
+        const name = config?.name;
+        const method = config?.method;
+        const includeRaw = config?.includeRaw;
+        if (method === "jsonMode") {
+            throw new Error(`ChatGoogleGenerativeAI only supports "functionCalling" as a method.`);
+        }
+        let functionName = name ?? "extract";
+        let outputParser;
+        let tools;
+        if (isZodSchema(schema)) {
+            const jsonSchema = zodToGenerativeAIParameters(schema);
+            tools = [
+                {
+                    functionDeclarations: [
+                        {
+                            name: functionName,
+                            description: jsonSchema.description ?? "A function available to call.",
+                            parameters: jsonSchema,
+                        },
+                    ],
+                },
+            ];
+            outputParser = new GoogleGenerativeAIToolsOutputParser({
+                returnSingle: true,
+                keyName: functionName,
+                zodSchema: schema,
+            });
+        }
+        else {
+            let geminiFunctionDefinition;
+            if (typeof schema.name === "string" &&
+                typeof schema.parameters === "object" &&
+                schema.parameters != null) {
+                geminiFunctionDefinition = schema;
+                functionName = schema.name;
+            }
+            else {
+                geminiFunctionDefinition = {
+                    name: functionName,
+                    description: schema.description ?? "",
+                    parameters: schema,
+                };
+            }
+            tools = [
+                {
+                    functionDeclarations: [geminiFunctionDefinition],
+                },
+            ];
+            outputParser = new GoogleGenerativeAIToolsOutputParser({
+                returnSingle: true,
+                keyName: functionName,
+            });
+        }
+        const llm = this.bind({
+            tools,
+        });
+        if (!includeRaw) {
+            return llm.pipe(outputParser).withConfig({
+                runName: "ChatGoogleGenerativeAIStructuredOutput",
+            });
+        }
+        const parserAssign = RunnablePassthrough.assign({
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            parsed: (input, config) => outputParser.invoke(input.raw, config),
+        });
+        const parserNone = RunnablePassthrough.assign({
+            parsed: () => null,
+        });
+        const parsedWithFallback = parserAssign.withFallbacks({
+            fallbacks: [parserNone],
+        });
+        return RunnableSequence.from([
+            {
+                raw: llm,
+            },
+            parsedWithFallback,
+        ]).withConfig({
+            runName: "StructuredOutputRunnable",
+        });
+    }
 }

package/dist/output_parsers.cjs

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleGenerativeAIToolsOutputParser = void 0;
+const output_parsers_1 = require("@langchain/core/output_parsers");
+class GoogleGenerativeAIToolsOutputParser extends output_parsers_1.BaseLLMOutputParser {
+    static lc_name() {
+        return "GoogleGenerativeAIToolsOutputParser";
+    }
+    constructor(params) {
+        super(params);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "google_genai", "output_parsers"]
+        });
+        Object.defineProperty(this, "returnId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /** The type of tool calls to return. */
+        Object.defineProperty(this, "keyName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Whether to return only the first tool call. */
+        Object.defineProperty(this, "returnSingle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "zodSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.keyName = params.keyName;
+        this.returnSingle = params.returnSingle ?? this.returnSingle;
+        this.zodSchema = params.zodSchema;
+    }
+    async _validateResult(result) {
+        if (this.zodSchema === undefined) {
+            return result;
+        }
+        const zodParsedResult = await this.zodSchema.safeParseAsync(result);
+        if (zodParsedResult.success) {
+            return zodParsedResult.data;
+        }
+        else {
+            throw new output_parsers_1.OutputParserException(`Failed to parse. Text: "${JSON.stringify(result, null, 2)}". Error: ${JSON.stringify(zodParsedResult.error.errors)}`, JSON.stringify(result, null, 2));
+        }
+    }
+    async parseResult(generations) {
+        const tools = generations.flatMap((generation) => {
+            const { message } = generation;
+            if (!("tool_calls" in message) || !Array.isArray(message.tool_calls)) {
+                return [];
+            }
+            return message.tool_calls;
+        });
+        if (tools[0] === undefined) {
+            throw new Error("No parseable tool calls provided to GoogleGenerativeAIToolsOutputParser.");
+        }
+        const [tool] = tools;
+        const validatedResult = await this._validateResult(tool.args);
+        return validatedResult;
+    }
+}
+exports.GoogleGenerativeAIToolsOutputParser = GoogleGenerativeAIToolsOutputParser;

package/dist/output_parsers.d.ts

@@ -0,0 +1,20 @@
+import type { z } from "zod";
+import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
+import { JsonOutputKeyToolsParserParams } from "@langchain/core/output_parsers/openai_tools";
+import { ChatGeneration } from "@langchain/core/outputs";
+interface GoogleGenerativeAIToolsOutputParserParams<T extends Record<string, any>> extends JsonOutputKeyToolsParserParams<T> {
+}
+export declare class GoogleGenerativeAIToolsOutputParser<T extends Record<string, any> = Record<string, any>> extends BaseLLMOutputParser<T> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    returnId: boolean;
+    /** The type of tool calls to return. */
+    keyName: string;
+    /** Whether to return only the first tool call. */
+    returnSingle: boolean;
+    zodSchema?: z.ZodType<T>;
+    constructor(params: GoogleGenerativeAIToolsOutputParserParams<T>);
+    protected _validateResult(result: unknown): Promise<T>;
+    parseResult(generations: ChatGeneration[]): Promise<T>;
+}
+export {};

package/dist/output_parsers.js

@@ -0,0 +1,71 @@
+import { BaseLLMOutputParser, OutputParserException, } from "@langchain/core/output_parsers";
+export class GoogleGenerativeAIToolsOutputParser extends BaseLLMOutputParser {
+    static lc_name() {
+        return "GoogleGenerativeAIToolsOutputParser";
+    }
+    constructor(params) {
+        super(params);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "google_genai", "output_parsers"]
+        });
+        Object.defineProperty(this, "returnId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /** The type of tool calls to return. */
+        Object.defineProperty(this, "keyName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Whether to return only the first tool call. */
+        Object.defineProperty(this, "returnSingle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "zodSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.keyName = params.keyName;
+        this.returnSingle = params.returnSingle ?? this.returnSingle;
+        this.zodSchema = params.zodSchema;
+    }
+    async _validateResult(result) {
+        if (this.zodSchema === undefined) {
+            return result;
+        }
+        const zodParsedResult = await this.zodSchema.safeParseAsync(result);
+        if (zodParsedResult.success) {
+            return zodParsedResult.data;
+        }
+        else {
+            throw new OutputParserException(`Failed to parse. Text: "${JSON.stringify(result, null, 2)}". Error: ${JSON.stringify(zodParsedResult.error.errors)}`, JSON.stringify(result, null, 2));
+        }
+    }
+    async parseResult(generations) {
+        const tools = generations.flatMap((generation) => {
+            const { message } = generation;
+            if (!("tool_calls" in message) || !Array.isArray(message.tool_calls)) {
+                return [];
+            }
+            return message.tool_calls;
+        });
+        if (tools[0] === undefined) {
+            throw new Error("No parseable tool calls provided to GoogleGenerativeAIToolsOutputParser.");
+        }
+        const [tool] = tools;
+        const validatedResult = await this._validateResult(tool.args);
+        return validatedResult;
+    }
+}

package/dist/{utils.cjs → utils/common.cjs}

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertResponseContentToChatGenerationChunk = exports.mapGenerateContentResultToChatResult = exports.convertBaseMessagesToContent = exports.convertMessageContentToParts = exports.convertAuthorToRole = exports.getMessageAuthor = void 0;
+exports.convertToGenerativeAITools = exports.convertResponseContentToChatGenerationChunk = exports.mapGenerateContentResultToChatResult = exports.convertBaseMessagesToContent = exports.convertMessageContentToParts = exports.convertAuthorToRole = exports.getMessageAuthor = void 0;
 const messages_1 = require("@langchain/core/messages");
 const outputs_1 = require("@langchain/core/outputs");
+const function_calling_1 = require("@langchain/core/utils/function_calling");
+const zod_to_genai_parameters_js_1 = require("./zod_to_genai_parameters.cjs");
 function getMessageAuthor(message) {
     const type = message._getType();
     if (messages_1.ChatMessage.isInstance(message)) {
@@ -142,6 +144,7 @@ function mapGenerateContentResultToChatResult(response) {
             },
         };
     }
+    const functionCalls = response.functionCalls();
     const [candidate] = response.candidates;
     const { content, ...generationInfo } = candidate;
     const text = content?.parts[0]?.text ?? "";
@@ -149,8 +152,10 @@ function mapGenerateContentResultToChatResult(response) {
         text,
         message: new messages_1.AIMessage({
             content: text,
-            name: !content ? undefined : content.role,
-            additional_kwargs: generationInfo,
+            tool_calls: functionCalls,
+            additional_kwargs: {
+                ...generationInfo,
+            },
         }),
         generationInfo,
     };
@@ -179,3 +184,25 @@ function convertResponseContentToChatGenerationChunk(response) {
     });
 }
 exports.convertResponseContentToChatGenerationChunk = convertResponseContentToChatGenerationChunk;
+function convertToGenerativeAITools(structuredTools) {
+    if (structuredTools.every((tool) => "functionDeclarations" in tool &&
+        Array.isArray(tool.functionDeclarations))) {
+        return structuredTools;
+    }
+    return [
+        {
+            functionDeclarations: structuredTools.map((structuredTool) => {
+                if ((0, function_calling_1.isStructuredTool)(structuredTool)) {
+                    const jsonSchema = (0, zod_to_genai_parameters_js_1.zodToGenerativeAIParameters)(structuredTool.schema);
+                    return {
+                        name: structuredTool.name,
+                        description: structuredTool.description,
+                        parameters: jsonSchema,
+                    };
+                }
+                return structuredTool;
+            }),
+        },
+    ];
+}
+exports.convertToGenerativeAITools = convertToGenerativeAITools;

package/dist/{utils.d.ts → utils/common.d.ts}

@@ -1,6 +1,7 @@
-import { EnhancedGenerateContentResponse, Content, Part } from "@google/generative-ai";
+import { EnhancedGenerateContentResponse, Content, Part, type FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool } from "@google/generative-ai";
 import { BaseMessage, MessageContent } from "@langchain/core/messages";
 import { ChatGenerationChunk, ChatResult } from "@langchain/core/outputs";
+import { StructuredToolInterface } from "@langchain/core/tools";
 export declare function getMessageAuthor(message: BaseMessage): string;
 /**
  * Maps a message type to a Google Generative AI chat author.
@@ -13,3 +14,4 @@ export declare function convertMessageContentToParts(content: MessageContent, is
 export declare function convertBaseMessagesToContent(messages: BaseMessage[], isMultimodalModel: boolean): Content[];
 export declare function mapGenerateContentResultToChatResult(response: EnhancedGenerateContentResponse): ChatResult;
 export declare function convertResponseContentToChatGenerationChunk(response: EnhancedGenerateContentResponse): ChatGenerationChunk | null;
+export declare function convertToGenerativeAITools(structuredTools: (StructuredToolInterface | Record<string, unknown>)[]): GoogleGenerativeAIFunctionDeclarationsTool[];

package/dist/{utils.js → utils/common.js}

@@ -1,5 +1,7 @@
 import { AIMessage, AIMessageChunk, ChatMessage, isBaseMessage, } from "@langchain/core/messages";
 import { ChatGenerationChunk, } from "@langchain/core/outputs";
+import { isStructuredTool } from "@langchain/core/utils/function_calling";
+import { zodToGenerativeAIParameters } from "./zod_to_genai_parameters.js";
 export function getMessageAuthor(message) {
     const type = message._getType();
     if (ChatMessage.isInstance(message)) {
@@ -135,6 +137,7 @@ export function mapGenerateContentResultToChatResult(response) {
             },
         };
     }
+    const functionCalls = response.functionCalls();
     const [candidate] = response.candidates;
     const { content, ...generationInfo } = candidate;
     const text = content?.parts[0]?.text ?? "";
@@ -142,8 +145,10 @@ export function mapGenerateContentResultToChatResult(response) {
         text,
         message: new AIMessage({
             content: text,
-            name: !content ? undefined : content.role,
-            additional_kwargs: generationInfo,
+            tool_calls: functionCalls,
+            additional_kwargs: {
+                ...generationInfo,
+            },
         }),
         generationInfo,
     };
@@ -170,3 +175,24 @@ export function convertResponseContentToChatGenerationChunk(response) {
         generationInfo,
     });
 }
+export function convertToGenerativeAITools(structuredTools) {
+    if (structuredTools.every((tool) => "functionDeclarations" in tool &&
+        Array.isArray(tool.functionDeclarations))) {
+        return structuredTools;
+    }
+    return [
+        {
+            functionDeclarations: structuredTools.map((structuredTool) => {
+                if (isStructuredTool(structuredTool)) {
+                    const jsonSchema = zodToGenerativeAIParameters(structuredTool.schema);
+                    return {
+                        name: structuredTool.name,
+                        description: structuredTool.description,
+                        parameters: jsonSchema,
+                    };
+                }
+                return structuredTool;
+            }),
+        },
+    ];
+}

package/dist/utils/zod_to_genai_parameters.cjs

@@ -0,0 +1,35 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zodToGenerativeAIParameters = void 0;
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+function removeAdditionalProperties(schema) {
+    const updatedSchema = { ...schema };
+    if (Object.hasOwn(updatedSchema, "additionalProperties")) {
+        delete updatedSchema.additionalProperties;
+    }
+    if (updatedSchema.properties) {
+        const keys = Object.keys(updatedSchema.properties);
+        removeProperties(updatedSchema.properties, keys, 0);
+    }
+    return updatedSchema;
+}
+function removeProperties(properties, keys, index) {
+    if (index >= keys.length || !properties) {
+        return;
+    }
+    const key = keys[index];
+    // eslint-disable-next-line no-param-reassign
+    properties[key] = removeAdditionalProperties(properties[key]);
+    removeProperties(properties, keys, index + 1);
+}
+function zodToGenerativeAIParameters(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+zodObj) {
+    // GenerativeAI doesn't accept either the $schema or additionalProperties
+    // attributes, so we need to explicitly remove them.
+    const jsonSchema = removeAdditionalProperties((0, zod_to_json_schema_1.zodToJsonSchema)(zodObj));
+    const { $schema, ...rest } = jsonSchema;
+    return rest;
+}
+exports.zodToGenerativeAIParameters = zodToGenerativeAIParameters;

package/dist/utils/zod_to_genai_parameters.d.ts

@@ -0,0 +1,11 @@
+import type { z } from "zod";
+import { type FunctionDeclarationSchema as GenerativeAIFunctionDeclarationSchema, FunctionDeclarationSchemaType } from "@google/generative-ai";
+export interface GenerativeAIJsonSchema extends Record<string, unknown> {
+    properties?: Record<string, GenerativeAIJsonSchema>;
+    type: FunctionDeclarationSchemaType;
+}
+export interface GenerativeAIJsonSchemaDirty extends GenerativeAIJsonSchema {
+    properties?: Record<string, GenerativeAIJsonSchemaDirty>;
+    additionalProperties?: boolean;
+}
+export declare function zodToGenerativeAIParameters(zodObj: z.ZodType<any>): GenerativeAIFunctionDeclarationSchema;

package/dist/utils/zod_to_genai_parameters.js

@@ -0,0 +1,31 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { zodToJsonSchema } from "zod-to-json-schema";
+function removeAdditionalProperties(schema) {
+    const updatedSchema = { ...schema };
+    if (Object.hasOwn(updatedSchema, "additionalProperties")) {
+        delete updatedSchema.additionalProperties;
+    }
+    if (updatedSchema.properties) {
+        const keys = Object.keys(updatedSchema.properties);
+        removeProperties(updatedSchema.properties, keys, 0);
+    }
+    return updatedSchema;
+}
+function removeProperties(properties, keys, index) {
+    if (index >= keys.length || !properties) {
+        return;
+    }
+    const key = keys[index];
+    // eslint-disable-next-line no-param-reassign
+    properties[key] = removeAdditionalProperties(properties[key]);
+    removeProperties(properties, keys, index + 1);
+}
+export function zodToGenerativeAIParameters(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+zodObj) {
+    // GenerativeAI doesn't accept either the $schema or additionalProperties
+    // attributes, so we need to explicitly remove them.
+    const jsonSchema = removeAdditionalProperties(zodToJsonSchema(zodObj));
+    const { $schema, ...rest } = jsonSchema;
+    return rest;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/google-genai",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "Sample integration for LangChain.js",
   "type": "module",
   "engines": {
@@ -14,37 +14,35 @@
   },
   "homepage": "https://github.com/langchain-ai/langchainjs/tree/main/libs/langchain-google-genai/",
   "scripts": {
-    "build": "yarn run build:deps && yarn clean && yarn build:esm && yarn build:cjs && yarn build:scripts",
-    "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",
-    "build:watch": "yarn create-entrypoints && tsc --outDir dist/ --watch",
-    "build:scripts": "yarn create-entrypoints && yarn check-tree-shaking",
+    "build": "yarn turbo:command build:internal --filter=@langchain/google-genai",
+    "build:internal": "yarn lc-build:v2 --create-entrypoints --pre --tree-shaking",
     "lint:eslint": "NODE_OPTIONS=--max-old-space-size=4096 eslint --cache --ext .ts,.js src/",
     "lint:dpdm": "dpdm --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts",
     "lint": "yarn lint:eslint && yarn lint:dpdm",
     "lint:fix": "yarn lint:eslint --fix && yarn lint:dpdm",
-    "clean": "rm -rf dist/ && NODE_OPTIONS=--max-old-space-size=4096 yarn lc-build --config ./langchain.config.js --create-entrypoints --pre",
+    "clean": "rm -rf .turbo dist/",
     "prepack": "yarn build",
-    "test": "yarn build:deps && NODE_OPTIONS=--experimental-vm-modules jest --testPathIgnorePatterns=\\.int\\.test.ts --testTimeout 30000 --maxWorkers=50%",
-    "test:watch": "yarn build:deps && NODE_OPTIONS=--experimental-vm-modules jest --watch --testPathIgnorePatterns=\\.int\\.test.ts",
-    "test:single": "yarn build:deps && NODE_OPTIONS=--experimental-vm-modules yarn run jest --config jest.config.cjs --testTimeout 100000",
-    "test:int": "yarn build:deps && NODE_OPTIONS=--experimental-vm-modules jest --testPathPattern=\\.int\\.test.ts --testTimeout 100000 --maxWorkers=50%",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --testPathIgnorePatterns=\\.int\\.test.ts --testTimeout 30000 --maxWorkers=50%",
+    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch --testPathIgnorePatterns=\\.int\\.test.ts",
+    "test:single": "NODE_OPTIONS=--experimental-vm-modules yarn run jest --config jest.config.cjs --testTimeout 100000",
+    "test:int": "NODE_OPTIONS=--experimental-vm-modules jest --testPathPattern=\\.int\\.test.ts --testTimeout 100000 --maxWorkers=50%",
+    "test:standard:unit": "NODE_OPTIONS=--experimental-vm-modules jest --testPathPattern=\\.standard\\.test.ts --testTimeout 100000 --maxWorkers=50%",
+    "test:standard:int": "NODE_OPTIONS=--experimental-vm-modules jest --testPathPattern=\\.standard\\.int\\.test.ts --testTimeout 100000 --maxWorkers=50%",
+    "test:standard": "yarn test:standard:unit && yarn test:standard:int",
     "format": "prettier --config .prettierrc --write \"src\"",
-    "format:check": "prettier --config .prettierrc --check \"src\"",
-    "move-cjs-to-dist": "yarn lc-build --config ./langchain.config.js --move-cjs-dist",
-    "create-entrypoints": "yarn lc-build --config ./langchain.config.js --create-entrypoints",
-    "check-tree-shaking": "yarn lc-build --config ./langchain.config.js --tree-shaking"
+    "format:check": "prettier --config .prettierrc --check \"src\""
   },
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
     "@google/generative-ai": "^0.7.0",
-    "@langchain/core": ">0.1.5  <0.3.0"
+    "@langchain/core": ">0.1.5  <0.3.0",
+    "zod-to-json-schema": "^3.22.4"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",
-    "@langchain/scripts": "~0.0",
+    "@langchain/scripts": "~0.0.14",
+    "@langchain/standard-tests": "workspace:*",
     "@swc/core": "^1.3.90",
     "@swc/jest": "^0.2.29",
     "@tsconfig/recommended": "^1.0.3",
@@ -65,7 +63,8 @@
     "release-it": "^15.10.1",
     "rollup": "^4.5.2",
     "ts-jest": "^29.1.0",
-    "typescript": "<5.2.0"
+    "typescript": "<5.2.0",
+    "zod": "^3.22.4"
   },
   "publishConfig": {
     "access": "public"