@langchain/google-common 0.1.3 → 0.1.5

package/dist/chat_models.cjs

@@ -356,6 +356,7 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
         }
         const llm = this.bind({
             tools,
+            tool_choice: functionName,
         });
         if (!includeRaw) {
             return llm.pipe(outputParser).withConfig({

package/dist/chat_models.js

@@ -352,6 +352,7 @@ export class ChatGoogleBase extends BaseChatModel {
         }
         const llm = this.bind({
             tools,
+            tool_choice: functionName,
         });
         if (!includeRaw) {
             return llm.pipe(outputParser).withConfig({

package/dist/embeddings.cjs

@@ -19,6 +19,10 @@ class EmbeddingsConnection extends connection_js_1.GoogleAIConnection {
     async buildUrlMethod() {
         return "predict";
     }
+    get modelPublisher() {
+        // All the embedding models are currently published by "google"
+        return "google";
+    }
     async formatData(input, parameters) {
         return {
             instances: input,

package/dist/embeddings.js

@@ -16,6 +16,10 @@ class EmbeddingsConnection extends GoogleAIConnection {
     async buildUrlMethod() {
         return "predict";
     }
+    get modelPublisher() {
+        // All the embedding models are currently published by "google"
+        return "google";
+    }
     async formatData(input, parameters) {
         return {
             instances: input,

package/dist/types.d.ts

@@ -226,6 +226,20 @@ export interface GeminiContent {
 }
 export interface GeminiTool {
     functionDeclarations?: GeminiFunctionDeclaration[];
+    googleSearchRetrieval?: GoogleSearchRetrieval;
+    retrieval?: VertexAIRetrieval;
+}
+export interface GoogleSearchRetrieval {
+    dynamicRetrievalConfig?: {
+        mode?: string;
+        dynamicThreshold?: number;
+    };
+}
+export interface VertexAIRetrieval {
+    vertexAiSearch: {
+        datastore: string;
+    };
+    disableAttribution?: boolean;
 }
 export interface GeminiFunctionDeclaration {
     name: string;

package/dist/utils/common.cjs

@@ -38,31 +38,42 @@ function processToolChoice(toolChoice, allowedFunctionNames) {
     throw new Error("Object inputs for tool_choice not supported.");
 }
 function convertToGeminiTools(tools) {
-    const geminiTools = [
-        {
-            functionDeclarations: [],
-        },
-    ];
+    const geminiTools = [];
+    let functionDeclarationsIndex = -1;
     tools.forEach((tool) => {
-        if ("functionDeclarations" in tool &&
-            Array.isArray(tool.functionDeclarations)) {
-            const funcs = tool.functionDeclarations;
-            geminiTools[0].functionDeclarations?.push(...funcs);
+        if ("googleSearchRetrieval" in tool || "retrieval" in tool) {
+            geminiTools.push(tool);
         }
-        else if ((0, function_calling_1.isLangChainTool)(tool)) {
-            const jsonSchema = (0, zod_to_gemini_parameters_js_1.zodToGeminiParameters)(tool.schema);
-            geminiTools[0].functionDeclarations?.push({
-                name: tool.name,
-                description: tool.description ?? `A function available to call.`,
-                parameters: jsonSchema,
-            });
-        }
-        else if ((0, base_1.isOpenAITool)(tool)) {
-            geminiTools[0].functionDeclarations?.push({
-                name: tool.function.name,
-                description: tool.function.description ?? `A function available to call.`,
-                parameters: (0, zod_to_gemini_parameters_js_1.jsonSchemaToGeminiParameters)(tool.function.parameters),
-            });
+        else {
+            if (functionDeclarationsIndex === -1) {
+                geminiTools.push({
+                    functionDeclarations: [],
+                });
+                functionDeclarationsIndex = geminiTools.length - 1;
+            }
+            if ("functionDeclarations" in tool &&
+                Array.isArray(tool.functionDeclarations)) {
+                const funcs = tool.functionDeclarations;
+                geminiTools[functionDeclarationsIndex].functionDeclarations.push(...funcs);
+            }
+            else if ((0, function_calling_1.isLangChainTool)(tool)) {
+                const jsonSchema = (0, zod_to_gemini_parameters_js_1.zodToGeminiParameters)(tool.schema);
+                geminiTools[functionDeclarationsIndex].functionDeclarations.push({
+                    name: tool.name,
+                    description: tool.description ?? `A function available to call.`,
+                    parameters: jsonSchema,
+                });
+            }
+            else if ((0, base_1.isOpenAITool)(tool)) {
+                geminiTools[functionDeclarationsIndex].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),
+                });
+            }
+            else {
+                throw new Error(`Received invalid tool: ${JSON.stringify(tool)}`);
+            }
         }
     });
     return geminiTools;

package/dist/utils/common.js

@@ -34,31 +34,42 @@ function processToolChoice(toolChoice, allowedFunctionNames) {
     throw new Error("Object inputs for tool_choice not supported.");
 }
 export function convertToGeminiTools(tools) {
-    const geminiTools = [
-        {
-            functionDeclarations: [],
-        },
-    ];
+    const geminiTools = [];
+    let functionDeclarationsIndex = -1;
     tools.forEach((tool) => {
-        if ("functionDeclarations" in tool &&
-            Array.isArray(tool.functionDeclarations)) {
-            const funcs = tool.functionDeclarations;
-            geminiTools[0].functionDeclarations?.push(...funcs);
+        if ("googleSearchRetrieval" in tool || "retrieval" in tool) {
+            geminiTools.push(tool);
         }
-        else if (isLangChainTool(tool)) {
-            const jsonSchema = zodToGeminiParameters(tool.schema);
-            geminiTools[0].functionDeclarations?.push({
-                name: tool.name,
-                description: tool.description ?? `A function available to call.`,
-                parameters: jsonSchema,
-            });
-        }
-        else if (isOpenAITool(tool)) {
-            geminiTools[0].functionDeclarations?.push({
-                name: tool.function.name,
-                description: tool.function.description ?? `A function available to call.`,
-                parameters: jsonSchemaToGeminiParameters(tool.function.parameters),
-            });
+        else {
+            if (functionDeclarationsIndex === -1) {
+                geminiTools.push({
+                    functionDeclarations: [],
+                });
+                functionDeclarationsIndex = geminiTools.length - 1;
+            }
+            if ("functionDeclarations" in tool &&
+                Array.isArray(tool.functionDeclarations)) {
+                const funcs = tool.functionDeclarations;
+                geminiTools[functionDeclarationsIndex].functionDeclarations.push(...funcs);
+            }
+            else if (isLangChainTool(tool)) {
+                const jsonSchema = zodToGeminiParameters(tool.schema);
+                geminiTools[functionDeclarationsIndex].functionDeclarations.push({
+                    name: tool.name,
+                    description: tool.description ?? `A function available to call.`,
+                    parameters: jsonSchema,
+                });
+            }
+            else if (isOpenAITool(tool)) {
+                geminiTools[functionDeclarationsIndex].functionDeclarations.push({
+                    name: tool.function.name,
+                    description: tool.function.description ?? `A function available to call.`,
+                    parameters: jsonSchemaToGeminiParameters(tool.function.parameters),
+                });
+            }
+            else {
+                throw new Error(`Received invalid tool: ${JSON.stringify(tool)}`);
+            }
         }
     });
     return geminiTools;

package/dist/utils/gemini.cjs

@@ -141,10 +141,10 @@ function getGeminiAPI(config) {
         if (!url) {
             throw new Error("Missing Image URL");
         }
-        const mineTypeAndData = extractMimeType(url);
-        if (mineTypeAndData) {
+        const mimeTypeAndData = extractMimeType(url);
+        if (mimeTypeAndData) {
             return {
-                inlineData: mineTypeAndData,
+                inlineData: mimeTypeAndData,
             };
         }
         else {
@@ -788,38 +788,39 @@ function getGeminiAPI(config) {
             parameters: jsonSchema,
         };
     }
-    function structuredToolsToGeminiTools(tools) {
-        return [
-            {
-                functionDeclarations: tools.map(structuredToolToFunctionDeclaration),
-            },
-        ];
-    }
     function formatTools(parameters) {
         const tools = parameters?.tools;
         if (!tools || tools.length === 0) {
             return [];
         }
-        if (tools.every(function_calling_1.isLangChainTool)) {
-            return structuredToolsToGeminiTools(tools);
-        }
-        else {
-            if (tools.length === 1 &&
-                (!("functionDeclarations" in tools[0]) ||
-                    !tools[0].functionDeclarations?.length)) {
-                return [];
-            }
-            return tools;
+        // Group all LangChain tools into a single functionDeclarations array
+        const langChainTools = tools.filter(function_calling_1.isLangChainTool);
+        const otherTools = tools.filter((tool) => !(0, function_calling_1.isLangChainTool)(tool));
+        const result = [...otherTools];
+        if (langChainTools.length > 0) {
+            result.push({
+                functionDeclarations: langChainTools.map(structuredToolToFunctionDeclaration),
+            });
         }
+        return result;
     }
     function formatToolConfig(parameters) {
         if (!parameters.tool_choice || typeof parameters.tool_choice !== "string") {
             return undefined;
         }
+        if (["auto", "any", "none"].includes(parameters.tool_choice)) {
+            return {
+                functionCallingConfig: {
+                    mode: parameters.tool_choice,
+                    allowedFunctionNames: parameters.allowed_function_names,
+                },
+            };
+        }
+        // force tool choice to be a single function name in case of structured output
         return {
             functionCallingConfig: {
-                mode: parameters.tool_choice,
-                allowedFunctionNames: parameters.allowed_function_names,
+                mode: "any",
+                allowedFunctionNames: [parameters.tool_choice],
             },
         };
     }

package/dist/utils/gemini.js

@@ -136,10 +136,10 @@ export function getGeminiAPI(config) {
         if (!url) {
             throw new Error("Missing Image URL");
         }
-        const mineTypeAndData = extractMimeType(url);
-        if (mineTypeAndData) {
+        const mimeTypeAndData = extractMimeType(url);
+        if (mimeTypeAndData) {
             return {
-                inlineData: mineTypeAndData,
+                inlineData: mimeTypeAndData,
             };
         }
         else {
@@ -783,38 +783,39 @@ export function getGeminiAPI(config) {
             parameters: jsonSchema,
         };
     }
-    function structuredToolsToGeminiTools(tools) {
-        return [
-            {
-                functionDeclarations: tools.map(structuredToolToFunctionDeclaration),
-            },
-        ];
-    }
     function formatTools(parameters) {
         const tools = parameters?.tools;
         if (!tools || tools.length === 0) {
             return [];
         }
-        if (tools.every(isLangChainTool)) {
-            return structuredToolsToGeminiTools(tools);
-        }
-        else {
-            if (tools.length === 1 &&
-                (!("functionDeclarations" in tools[0]) ||
-                    !tools[0].functionDeclarations?.length)) {
-                return [];
-            }
-            return tools;
+        // Group all LangChain tools into a single functionDeclarations array
+        const langChainTools = tools.filter(isLangChainTool);
+        const otherTools = tools.filter((tool) => !isLangChainTool(tool));
+        const result = [...otherTools];
+        if (langChainTools.length > 0) {
+            result.push({
+                functionDeclarations: langChainTools.map(structuredToolToFunctionDeclaration),
+            });
         }
+        return result;
     }
     function formatToolConfig(parameters) {
         if (!parameters.tool_choice || typeof parameters.tool_choice !== "string") {
             return undefined;
         }
+        if (["auto", "any", "none"].includes(parameters.tool_choice)) {
+            return {
+                functionCallingConfig: {
+                    mode: parameters.tool_choice,
+                    allowedFunctionNames: parameters.allowed_function_names,
+                },
+            };
+        }
+        // force tool choice to be a single function name in case of structured output
         return {
             functionCallingConfig: {
-                mode: parameters.tool_choice,
-                allowedFunctionNames: parameters.allowed_function_names,
+                mode: "any",
+                allowedFunctionNames: [parameters.tool_choice],
             },
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/google-common",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Core types and classes for Google services.",
   "type": "module",
   "engines": {