@langchain/google-genai 0.1.2 → 0.1.3-rc.0

package/dist/chat_models.cjs

@@ -9,6 +9,7 @@ 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");
+const tools_js_1 = require("./utils/tools.cjs");
 /**
  * Google Generative AI chat model integration.
  *
@@ -522,59 +523,20 @@ class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
         return "googlegenerativeai";
     }
     bindTools(tools, kwargs) {
-        return this.bind({ tools: (0, common_js_1.convertToGenerativeAITools)(tools), ...kwargs });
+        return this.bind({ tools: (0, tools_js_1.convertToolsToGenAI)(tools)?.tools, ...kwargs });
     }
     invocationParams(options) {
-        let genaiTools;
-        if (Array.isArray(options?.tools) &&
-            !options?.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
-            genaiTools = (0, common_js_1.convertToGenerativeAITools)(options?.tools);
-        }
-        else {
-            genaiTools = options?.tools;
-        }
-        let toolConfig;
-        if (genaiTools?.length && options?.tool_choice) {
-            if (["any", "auto", "none"].some((c) => c === options.tool_choice)) {
-                const modeMap = {
-                    any: generative_ai_1.FunctionCallingMode.ANY,
-                    auto: generative_ai_1.FunctionCallingMode.AUTO,
-                    none: generative_ai_1.FunctionCallingMode.NONE,
-                };
-                toolConfig = {
-                    functionCallingConfig: {
-                        mode: modeMap[options.tool_choice] ??
-                            "MODE_UNSPECIFIED",
-                        allowedFunctionNames: options.allowedFunctionNames,
-                    },
-                };
-            }
-            else if (typeof options.tool_choice === "string") {
-                toolConfig = {
-                    functionCallingConfig: {
-                        mode: generative_ai_1.FunctionCallingMode.ANY,
-                        allowedFunctionNames: [
-                            ...(options.allowedFunctionNames ?? []),
-                            options.tool_choice,
-                        ],
-                    },
-                };
-            }
-            if (!options.tool_choice && options.allowedFunctionNames) {
-                toolConfig = {
-                    functionCallingConfig: {
-                        mode: generative_ai_1.FunctionCallingMode.ANY,
-                        allowedFunctionNames: options.allowedFunctionNames,
-                    },
-                };
-            }
-        }
+        const toolsAndConfig = options?.tools?.length
+            ? (0, tools_js_1.convertToolsToGenAI)(options.tools, {
+                toolChoice: options.tool_choice,
+                allowedFunctionNames: options.allowedFunctionNames,
+            })
+            : undefined;
         return {
-            tools: genaiTools,
-            toolConfig,
+            ...(toolsAndConfig?.tools ? { tools: toolsAndConfig.tools } : {}),
+            ...(toolsAndConfig?.toolConfig
+                ? { toolConfig: toolsAndConfig.toolConfig }
+                : {}),
         };
     }
     async _generate(messages, options, runManager) {

package/dist/chat_models.js

@@ -1,11 +1,12 @@
-import { GoogleGenerativeAI as GenerativeAI, FunctionCallingMode, } from "@google/generative-ai";
+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 { 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 { convertBaseMessagesToContent, convertResponseContentToChatGenerationChunk, mapGenerateContentResultToChatResult, } from "./utils/common.js";
 import { GoogleGenerativeAIToolsOutputParser } from "./output_parsers.js";
+import { convertToolsToGenAI } from "./utils/tools.js";
 /**
  * Google Generative AI chat model integration.
  *
@@ -519,59 +520,20 @@ export class ChatGoogleGenerativeAI extends BaseChatModel {
         return "googlegenerativeai";
     }
     bindTools(tools, kwargs) {
-        return this.bind({ tools: convertToGenerativeAITools(tools), ...kwargs });
+        return this.bind({ tools: convertToolsToGenAI(tools)?.tools, ...kwargs });
     }
     invocationParams(options) {
-        let genaiTools;
-        if (Array.isArray(options?.tools) &&
-            !options?.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
-            genaiTools = convertToGenerativeAITools(options?.tools);
-        }
-        else {
-            genaiTools = options?.tools;
-        }
-        let toolConfig;
-        if (genaiTools?.length && options?.tool_choice) {
-            if (["any", "auto", "none"].some((c) => c === options.tool_choice)) {
-                const modeMap = {
-                    any: FunctionCallingMode.ANY,
-                    auto: FunctionCallingMode.AUTO,
-                    none: FunctionCallingMode.NONE,
-                };
-                toolConfig = {
-                    functionCallingConfig: {
-                        mode: modeMap[options.tool_choice] ??
-                            "MODE_UNSPECIFIED",
-                        allowedFunctionNames: options.allowedFunctionNames,
-                    },
-                };
-            }
-            else if (typeof options.tool_choice === "string") {
-                toolConfig = {
-                    functionCallingConfig: {
-                        mode: FunctionCallingMode.ANY,
-                        allowedFunctionNames: [
-                            ...(options.allowedFunctionNames ?? []),
-                            options.tool_choice,
-                        ],
-                    },
-                };
-            }
-            if (!options.tool_choice && options.allowedFunctionNames) {
-                toolConfig = {
-                    functionCallingConfig: {
-                        mode: FunctionCallingMode.ANY,
-                        allowedFunctionNames: options.allowedFunctionNames,
-                    },
-                };
-            }
-        }
+        const toolsAndConfig = options?.tools?.length
+            ? convertToolsToGenAI(options.tools, {
+                toolChoice: options.tool_choice,
+                allowedFunctionNames: options.allowedFunctionNames,
+            })
+            : undefined;
         return {
-            tools: genaiTools,
-            toolConfig,
+            ...(toolsAndConfig?.tools ? { tools: toolsAndConfig.tools } : {}),
+            ...(toolsAndConfig?.toolConfig
+                ? { toolConfig: toolsAndConfig.toolConfig }
+                : {}),
         };
     }
     async _generate(messages, options, runManager) {

package/dist/types.d.ts

@@ -1,3 +1,3 @@
-import { FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool } from "@google/generative-ai";
+import { CodeExecutionTool, FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool, GoogleSearchRetrievalTool } from "@google/generative-ai";
 import { BindToolsInput } from "@langchain/core/language_models/chat_models";
-export type GoogleGenerativeAIToolType = BindToolsInput | GoogleGenerativeAIFunctionDeclarationsTool;
+export type GoogleGenerativeAIToolType = BindToolsInput | GoogleGenerativeAIFunctionDeclarationsTool | CodeExecutionTool | GoogleSearchRetrievalTool;

package/dist/utils/common.cjs

@@ -71,7 +71,7 @@ function convertMessageContentToParts(message, isMultimodalModel) {
             },
         }));
     }
-    else if (message._getType() === "tool" && message.name && message.content) {
+    else if (message.getType() === "tool" && message.name && message.content) {
         functionResponses = [
             {
                 functionResponse: {
@@ -88,6 +88,16 @@ function convertMessageContentToParts(message, isMultimodalModel) {
                     text: c.text,
                 };
             }
+            else if (c.type === "executableCode") {
+                return {
+                    executableCode: c.executableCode,
+                };
+            }
+            else if (c.type === "codeExecutionResult") {
+                return {
+                    codeExecutionResult: c.codeExecutionResult,
+                };
+            }
             if (c.type === "image_url") {
                 if (!isMultimodalModel) {
                     throw new Error(`This model does not support images`);
@@ -192,12 +202,45 @@ function mapGenerateContentResultToChatResult(response, extra) {
     }
     const functionCalls = response.functionCalls();
     const [candidate] = response.candidates;
-    const { content, ...generationInfo } = candidate;
-    const text = content?.parts[0]?.text ?? "";
+    const { content: candidateContent, ...generationInfo } = candidate;
+    let content;
+    if (candidateContent?.parts.length === 1 && candidateContent.parts[0].text) {
+        content = candidateContent.parts[0].text;
+    }
+    else {
+        content = candidateContent.parts.map((p) => {
+            if ("text" in p) {
+                return {
+                    type: "text",
+                    text: p.text,
+                };
+            }
+            else if ("executableCode" in p) {
+                return {
+                    type: "executableCode",
+                    executableCode: p.executableCode,
+                };
+            }
+            else if ("codeExecutionResult" in p) {
+                return {
+                    type: "codeExecutionResult",
+                    codeExecutionResult: p.codeExecutionResult,
+                };
+            }
+            return p;
+        });
+    }
+    let text = "";
+    if (typeof content === "string") {
+        text = content;
+    }
+    else if ("text" in content[0]) {
+        text = content[0].text;
+    }
     const generation = {
         text,
         message: new messages_1.AIMessage({
-            content: text,
+            content,
             tool_calls: functionCalls?.map((fc) => ({
                 ...fc,
                 type: "tool_call",
@@ -220,8 +263,43 @@ function convertResponseContentToChatGenerationChunk(response, extra) {
     }
     const functionCalls = response.functionCalls();
     const [candidate] = response.candidates;
-    const { content, ...generationInfo } = candidate;
-    const text = content?.parts?.[0]?.text ?? "";
+    const { content: candidateContent, ...generationInfo } = candidate;
+    let content;
+    // Checks if some parts do not have text. If false, it means that the content is a string.
+    if (candidateContent?.parts &&
+        candidateContent.parts.every((p) => "text" in p)) {
+        content = candidateContent.parts.map((p) => p.text).join("");
+    }
+    else if (candidateContent.parts) {
+        content = candidateContent.parts.map((p) => {
+            if ("text" in p) {
+                return {
+                    type: "text",
+                    text: p.text,
+                };
+            }
+            else if ("executableCode" in p) {
+                return {
+                    type: "executableCode",
+                    executableCode: p.executableCode,
+                };
+            }
+            else if ("codeExecutionResult" in p) {
+                return {
+                    type: "codeExecutionResult",
+                    codeExecutionResult: p.codeExecutionResult,
+                };
+            }
+            return p;
+        });
+    }
+    let text = "";
+    if (content && typeof content === "string") {
+        text = content;
+    }
+    else if (content && typeof content === "object" && "text" in content[0]) {
+        text = content[0].text;
+    }
     const toolCallChunks = [];
     if (functionCalls) {
         toolCallChunks.push(...functionCalls.map((fc) => ({
@@ -234,8 +312,8 @@ function convertResponseContentToChatGenerationChunk(response, extra) {
     return new outputs_1.ChatGenerationChunk({
         text,
         message: new messages_1.AIMessageChunk({
-            content: text,
-            name: !content ? undefined : content.role,
+            content: content || "",
+            name: !candidateContent ? undefined : candidateContent.role,
             tool_call_chunks: toolCallChunks,
             // Each chunk can have unique "generationInfo", and merging strategy is unclear,
             // so leave blank for now.

package/dist/utils/common.js

@@ -66,7 +66,7 @@ export function convertMessageContentToParts(message, isMultimodalModel) {
             },
         }));
     }
-    else if (message._getType() === "tool" && message.name && message.content) {
+    else if (message.getType() === "tool" && message.name && message.content) {
         functionResponses = [
             {
                 functionResponse: {
@@ -83,6 +83,16 @@ export function convertMessageContentToParts(message, isMultimodalModel) {
                     text: c.text,
                 };
             }
+            else if (c.type === "executableCode") {
+                return {
+                    executableCode: c.executableCode,
+                };
+            }
+            else if (c.type === "codeExecutionResult") {
+                return {
+                    codeExecutionResult: c.codeExecutionResult,
+                };
+            }
             if (c.type === "image_url") {
                 if (!isMultimodalModel) {
                     throw new Error(`This model does not support images`);
@@ -185,12 +195,45 @@ export function mapGenerateContentResultToChatResult(response, extra) {
     }
     const functionCalls = response.functionCalls();
     const [candidate] = response.candidates;
-    const { content, ...generationInfo } = candidate;
-    const text = content?.parts[0]?.text ?? "";
+    const { content: candidateContent, ...generationInfo } = candidate;
+    let content;
+    if (candidateContent?.parts.length === 1 && candidateContent.parts[0].text) {
+        content = candidateContent.parts[0].text;
+    }
+    else {
+        content = candidateContent.parts.map((p) => {
+            if ("text" in p) {
+                return {
+                    type: "text",
+                    text: p.text,
+                };
+            }
+            else if ("executableCode" in p) {
+                return {
+                    type: "executableCode",
+                    executableCode: p.executableCode,
+                };
+            }
+            else if ("codeExecutionResult" in p) {
+                return {
+                    type: "codeExecutionResult",
+                    codeExecutionResult: p.codeExecutionResult,
+                };
+            }
+            return p;
+        });
+    }
+    let text = "";
+    if (typeof content === "string") {
+        text = content;
+    }
+    else if ("text" in content[0]) {
+        text = content[0].text;
+    }
     const generation = {
         text,
         message: new AIMessage({
-            content: text,
+            content,
             tool_calls: functionCalls?.map((fc) => ({
                 ...fc,
                 type: "tool_call",
@@ -212,8 +255,43 @@ export function convertResponseContentToChatGenerationChunk(response, extra) {
     }
     const functionCalls = response.functionCalls();
     const [candidate] = response.candidates;
-    const { content, ...generationInfo } = candidate;
-    const text = content?.parts?.[0]?.text ?? "";
+    const { content: candidateContent, ...generationInfo } = candidate;
+    let content;
+    // Checks if some parts do not have text. If false, it means that the content is a string.
+    if (candidateContent?.parts &&
+        candidateContent.parts.every((p) => "text" in p)) {
+        content = candidateContent.parts.map((p) => p.text).join("");
+    }
+    else if (candidateContent.parts) {
+        content = candidateContent.parts.map((p) => {
+            if ("text" in p) {
+                return {
+                    type: "text",
+                    text: p.text,
+                };
+            }
+            else if ("executableCode" in p) {
+                return {
+                    type: "executableCode",
+                    executableCode: p.executableCode,
+                };
+            }
+            else if ("codeExecutionResult" in p) {
+                return {
+                    type: "codeExecutionResult",
+                    codeExecutionResult: p.codeExecutionResult,
+                };
+            }
+            return p;
+        });
+    }
+    let text = "";
+    if (content && typeof content === "string") {
+        text = content;
+    }
+    else if (content && typeof content === "object" && "text" in content[0]) {
+        text = content[0].text;
+    }
     const toolCallChunks = [];
     if (functionCalls) {
         toolCallChunks.push(...functionCalls.map((fc) => ({
@@ -226,8 +304,8 @@ export function convertResponseContentToChatGenerationChunk(response, extra) {
     return new ChatGenerationChunk({
         text,
         message: new AIMessageChunk({
-            content: text,
-            name: !content ? undefined : content.role,
+            content: content || "",
+            name: !candidateContent ? undefined : candidateContent.role,
             tool_call_chunks: toolCallChunks,
             // Each chunk can have unique "generationInfo", and merging strategy is unclear,
             // so leave blank for now.

package/dist/utils/tools.cjs

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToolsToGenAI = void 0;
+const generative_ai_1 = require("@google/generative-ai");
+const function_calling_1 = require("@langchain/core/utils/function_calling");
+const common_js_1 = require("./common.cjs");
+function convertToolsToGenAI(tools, extra) {
+    // Extract function declaration processing to a separate function
+    const genAITools = processTools(tools);
+    // Simplify tool config creation
+    const toolConfig = createToolConfig(genAITools, extra);
+    return { tools: genAITools, toolConfig };
+}
+exports.convertToolsToGenAI = convertToolsToGenAI;
+function processTools(tools) {
+    let functionDeclarationTools = [];
+    const genAITools = [];
+    tools.forEach((tool) => {
+        if ((0, function_calling_1.isLangChainTool)(tool)) {
+            const [convertedTool] = (0, common_js_1.convertToGenerativeAITools)([
+                tool,
+            ]);
+            if (convertedTool.functionDeclarations) {
+                functionDeclarationTools.push(...convertedTool.functionDeclarations);
+            }
+        }
+        else {
+            genAITools.push(tool);
+        }
+    });
+    const genAIFunctionDeclaration = genAITools.find((t) => "functionDeclarations" in t);
+    if (genAIFunctionDeclaration) {
+        return genAITools.map((tool) => {
+            if (functionDeclarationTools?.length > 0 &&
+                "functionDeclarations" in tool) {
+                const newTool = {
+                    functionDeclarations: [
+                        ...(tool.functionDeclarations || []),
+                        ...functionDeclarationTools,
+                    ],
+                };
+                // Clear the functionDeclarationTools array so it is not passed again
+                functionDeclarationTools = [];
+                return newTool;
+            }
+            return tool;
+        });
+    }
+    return [
+        ...genAITools,
+        ...(functionDeclarationTools.length > 0
+            ? [
+                {
+                    functionDeclarations: functionDeclarationTools,
+                },
+            ]
+            : []),
+    ];
+}
+function createToolConfig(genAITools, extra) {
+    if (!genAITools.length || !extra)
+        return undefined;
+    const { toolChoice, allowedFunctionNames } = extra;
+    const modeMap = {
+        any: generative_ai_1.FunctionCallingMode.ANY,
+        auto: generative_ai_1.FunctionCallingMode.AUTO,
+        none: generative_ai_1.FunctionCallingMode.NONE,
+    };
+    if (toolChoice && ["any", "auto", "none"].includes(toolChoice)) {
+        return {
+            functionCallingConfig: {
+                mode: modeMap[toolChoice] ?? "MODE_UNSPECIFIED",
+                allowedFunctionNames,
+            },
+        };
+    }
+    if (typeof toolChoice === "string" || allowedFunctionNames) {
+        return {
+            functionCallingConfig: {
+                mode: generative_ai_1.FunctionCallingMode.ANY,
+                allowedFunctionNames: [
+                    ...(allowedFunctionNames ?? []),
+                    ...(toolChoice && typeof toolChoice === "string" ? [toolChoice] : []),
+                ],
+            },
+        };
+    }
+    return undefined;
+}

package/dist/utils/tools.d.ts

@@ -0,0 +1,10 @@
+import { Tool as GenerativeAITool, ToolConfig } from "@google/generative-ai";
+import { ToolChoice } from "@langchain/core/language_models/chat_models";
+import { GoogleGenerativeAIToolType } from "../types.js";
+export declare function convertToolsToGenAI(tools: GoogleGenerativeAIToolType[], extra?: {
+    toolChoice?: ToolChoice;
+    allowedFunctionNames?: string[];
+}): {
+    tools: GenerativeAITool[];
+    toolConfig?: ToolConfig;
+};

package/dist/utils/tools.js

@@ -0,0 +1,85 @@
+import { FunctionCallingMode, } from "@google/generative-ai";
+import { isLangChainTool } from "@langchain/core/utils/function_calling";
+import { convertToGenerativeAITools } from "./common.js";
+export function convertToolsToGenAI(tools, extra) {
+    // Extract function declaration processing to a separate function
+    const genAITools = processTools(tools);
+    // Simplify tool config creation
+    const toolConfig = createToolConfig(genAITools, extra);
+    return { tools: genAITools, toolConfig };
+}
+function processTools(tools) {
+    let functionDeclarationTools = [];
+    const genAITools = [];
+    tools.forEach((tool) => {
+        if (isLangChainTool(tool)) {
+            const [convertedTool] = convertToGenerativeAITools([
+                tool,
+            ]);
+            if (convertedTool.functionDeclarations) {
+                functionDeclarationTools.push(...convertedTool.functionDeclarations);
+            }
+        }
+        else {
+            genAITools.push(tool);
+        }
+    });
+    const genAIFunctionDeclaration = genAITools.find((t) => "functionDeclarations" in t);
+    if (genAIFunctionDeclaration) {
+        return genAITools.map((tool) => {
+            if (functionDeclarationTools?.length > 0 &&
+                "functionDeclarations" in tool) {
+                const newTool = {
+                    functionDeclarations: [
+                        ...(tool.functionDeclarations || []),
+                        ...functionDeclarationTools,
+                    ],
+                };
+                // Clear the functionDeclarationTools array so it is not passed again
+                functionDeclarationTools = [];
+                return newTool;
+            }
+            return tool;
+        });
+    }
+    return [
+        ...genAITools,
+        ...(functionDeclarationTools.length > 0
+            ? [
+                {
+                    functionDeclarations: functionDeclarationTools,
+                },
+            ]
+            : []),
+    ];
+}
+function createToolConfig(genAITools, extra) {
+    if (!genAITools.length || !extra)
+        return undefined;
+    const { toolChoice, allowedFunctionNames } = extra;
+    const modeMap = {
+        any: FunctionCallingMode.ANY,
+        auto: FunctionCallingMode.AUTO,
+        none: FunctionCallingMode.NONE,
+    };
+    if (toolChoice && ["any", "auto", "none"].includes(toolChoice)) {
+        return {
+            functionCallingConfig: {
+                mode: modeMap[toolChoice] ?? "MODE_UNSPECIFIED",
+                allowedFunctionNames,
+            },
+        };
+    }
+    if (typeof toolChoice === "string" || allowedFunctionNames) {
+        return {
+            functionCallingConfig: {
+                mode: FunctionCallingMode.ANY,
+                allowedFunctionNames: [
+                    ...(allowedFunctionNames ?? []),
+                    ...(toolChoice && typeof toolChoice === "string" ? [toolChoice] : []),
+                ],
+            },
+        };
+    }
+    return undefined;
+}

package/dist/utils/zod_to_genai_parameters.d.ts

@@ -1,5 +1,5 @@
 import type { z } from "zod";
-import { type FunctionDeclarationSchema as GenerativeAIFunctionDeclarationSchema, FunctionDeclarationSchemaType } from "@google/generative-ai";
+import { type FunctionDeclarationSchema as GenerativeAIFunctionDeclarationSchema, type SchemaType as FunctionDeclarationSchemaType } from "@google/generative-ai";
 export interface GenerativeAIJsonSchema extends Record<string, unknown> {
     properties?: Record<string, GenerativeAIJsonSchema>;
     type: FunctionDeclarationSchemaType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/google-genai",
-  "version": "0.1.2",
+  "version": "0.1.3-rc.0",
   "description": "Google Generative AI integration for LangChain.js",
   "type": "module",
   "engines": {
@@ -35,11 +35,11 @@
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@google/generative-ai": "^0.7.0",
+    "@google/generative-ai": "^0.21.0",
     "zod-to-json-schema": "^3.22.4"
   },
   "peerDependencies": {
-    "@langchain/core": ">=0.2.21 <0.4.0"
+    "@langchain/core": ">=0.3.17 <0.4.0"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",