@langchain/google-common 0.1.4 → 0.1.6

package/dist/chat_models.cjs

@@ -53,10 +53,33 @@ class ChatConnection extends connection_js_1.AbstractGoogleLLMConnection {
         }
         return true;
     }
+    computeGoogleSearchToolAdjustmentFromModel() {
+        if (this.modelName.startsWith("gemini-1.0")) {
+            return "googleSearchRetrieval";
+        }
+        else if (this.modelName.startsWith("gemini-1.5")) {
+            return "googleSearchRetrieval";
+        }
+        else {
+            return "googleSearch";
+        }
+    }
+    computeGoogleSearchToolAdjustment(apiConfig) {
+        const adj = apiConfig.googleSearchToolAdjustment;
+        if (adj === undefined || adj === true) {
+            return this.computeGoogleSearchToolAdjustmentFromModel();
+        }
+        else {
+            return adj;
+        }
+    }
     buildGeminiAPI() {
+        const apiConfig = this.apiConfig ?? {};
+        const googleSearchToolAdjustment = this.computeGoogleSearchToolAdjustment(apiConfig);
         const geminiConfig = {
             useSystemInstruction: this.useSystemInstruction,
-            ...this.apiConfig,
+            googleSearchToolAdjustment,
+            ...apiConfig,
         };
         return (0, gemini_js_1.getGeminiAPI)(geminiConfig);
     }
@@ -199,7 +222,13 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
         return new auth_js_1.ApiKeyGoogleAuth(apiKey);
     }
     buildApiKey(fields) {
-        return fields?.apiKey ?? (0, env_1.getEnvironmentVariable)("GOOGLE_API_KEY");
+        if (fields?.platformType !== "gcp") {
+            return fields?.apiKey ?? (0, env_1.getEnvironmentVariable)("GOOGLE_API_KEY");
+        }
+        else {
+            // GCP doesn't support API Keys
+            return undefined;
+        }
     }
     buildClient(fields) {
         const apiKey = this.buildApiKey(fields);
@@ -356,6 +385,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.d.ts

@@ -7,15 +7,17 @@ import { BaseLanguageModelInput, StructuredOutputMethodOptions } from "@langchai
 import type { z } from "zod";
 import { Runnable } from "@langchain/core/runnables";
 import { AsyncCaller } from "@langchain/core/utils/async_caller";
-import { GoogleAIBaseLLMInput, GoogleAIModelParams, GoogleAISafetySetting, GoogleConnectionParams, GooglePlatformType, GoogleAIBaseLanguageModelCallOptions, GoogleAIAPI, GoogleAIAPIParams } from "./types.js";
+import { GoogleAIBaseLLMInput, GoogleAIModelParams, GoogleAISafetySetting, GoogleConnectionParams, GooglePlatformType, GoogleAIBaseLanguageModelCallOptions, GoogleAIAPI, GoogleAIAPIParams, GoogleSearchToolSetting } from "./types.js";
 import { AbstractGoogleLLMConnection } from "./connection.js";
 import { GoogleAbstractedClient } from "./auth.js";
-import type { GoogleBaseLLMInput, GoogleAISafetyHandler, GoogleAISafetyParams, GoogleAIToolType } from "./types.js";
+import type { GoogleBaseLLMInput, GoogleAISafetyHandler, GoogleAISafetyParams, GoogleAIToolType, GeminiAPIConfig } from "./types.js";
 export declare class ChatConnection<AuthOptions> extends AbstractGoogleLLMConnection<BaseMessage[], AuthOptions> {
     convertSystemMessageToHumanContent: boolean | undefined;
     constructor(fields: GoogleAIBaseLLMInput<AuthOptions> | undefined, caller: AsyncCaller, client: GoogleAbstractedClient, streaming: boolean);
     get useSystemInstruction(): boolean;
     get computeUseSystemInstruction(): boolean;
+    computeGoogleSearchToolAdjustmentFromModel(): Exclude<GoogleSearchToolSetting, boolean>;
+    computeGoogleSearchToolAdjustment(apiConfig: GeminiAPIConfig): Exclude<GoogleSearchToolSetting, true>;
     buildGeminiAPI(): GoogleAIAPI;
     get api(): GoogleAIAPI;
 }

package/dist/chat_models.js

@@ -50,10 +50,33 @@ export class ChatConnection extends AbstractGoogleLLMConnection {
         }
         return true;
     }
+    computeGoogleSearchToolAdjustmentFromModel() {
+        if (this.modelName.startsWith("gemini-1.0")) {
+            return "googleSearchRetrieval";
+        }
+        else if (this.modelName.startsWith("gemini-1.5")) {
+            return "googleSearchRetrieval";
+        }
+        else {
+            return "googleSearch";
+        }
+    }
+    computeGoogleSearchToolAdjustment(apiConfig) {
+        const adj = apiConfig.googleSearchToolAdjustment;
+        if (adj === undefined || adj === true) {
+            return this.computeGoogleSearchToolAdjustmentFromModel();
+        }
+        else {
+            return adj;
+        }
+    }
     buildGeminiAPI() {
+        const apiConfig = this.apiConfig ?? {};
+        const googleSearchToolAdjustment = this.computeGoogleSearchToolAdjustment(apiConfig);
         const geminiConfig = {
             useSystemInstruction: this.useSystemInstruction,
-            ...this.apiConfig,
+            googleSearchToolAdjustment,
+            ...apiConfig,
         };
         return getGeminiAPI(geminiConfig);
     }
@@ -195,7 +218,13 @@ export class ChatGoogleBase extends BaseChatModel {
         return new ApiKeyGoogleAuth(apiKey);
     }
     buildApiKey(fields) {
-        return fields?.apiKey ?? getEnvironmentVariable("GOOGLE_API_KEY");
+        if (fields?.platformType !== "gcp") {
+            return fields?.apiKey ?? getEnvironmentVariable("GOOGLE_API_KEY");
+        }
+        else {
+            // GCP doesn't support API Keys
+            return undefined;
+        }
     }
     buildClient(fields) {
         const apiKey = this.buildApiKey(fields);
@@ -352,6 +381,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/index.cjs

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./chat_models.cjs"), exports);
 __exportStar(require("./llms.cjs"), exports);
 __exportStar(require("./embeddings.cjs"), exports);
+__exportStar(require("./output_parsers.cjs"), exports);
 __exportStar(require("./auth.cjs"), exports);
 __exportStar(require("./connection.cjs"), exports);
 __exportStar(require("./types.cjs"), exports);

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./chat_models.js";
 export * from "./llms.js";
 export * from "./embeddings.js";
+export * from "./output_parsers.js";
 export * from "./auth.js";
 export * from "./connection.js";
 export * from "./types.js";

package/dist/index.js

@@ -1,6 +1,7 @@
 export * from "./chat_models.js";
 export * from "./llms.js";
 export * from "./embeddings.js";
+export * from "./output_parsers.js";
 export * from "./auth.js";
 export * from "./connection.js";
 export * from "./types.js";

package/dist/output_parsers.cjs

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkdownGoogleSearchOutputParser = exports.SimpleGoogleSearchOutputParser = exports.BaseGoogleSearchOutputParser = void 0;
+const output_parsers_1 = require("@langchain/core/output_parsers");
+class BaseGoogleSearchOutputParser extends output_parsers_1.BaseLLMOutputParser {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["google_common", "output_parsers"]
+        });
+    }
+    generationToGroundingInfo(generation) {
+        if ("message" in generation) {
+            const responseMetadata = generation?.message?.response_metadata;
+            const metadata = responseMetadata.groundingMetadata;
+            const supports = responseMetadata.groundingSupport ?? metadata.groundingSupports ?? [];
+            if (metadata) {
+                return {
+                    metadata,
+                    supports,
+                };
+            }
+        }
+        return undefined;
+    }
+    generationsToGroundingInfo(generations) {
+        for (const generation of generations) {
+            const info = this.generationToGroundingInfo(generation);
+            if (info !== undefined) {
+                return info;
+            }
+        }
+        return undefined;
+    }
+    generationToString(generation) {
+        if ("message" in generation) {
+            const content = generation?.message?.content;
+            if (typeof content === "string") {
+                return content;
+            }
+            else {
+                return content
+                    .map((c) => {
+                    if (c?.type === "text") {
+                        return c?.text ?? "";
+                    }
+                    else {
+                        return "";
+                    }
+                })
+                    .reduce((previousValue, currentValue) => `${previousValue}${currentValue}`);
+            }
+        }
+        return generation.text;
+    }
+    generationsToString(generations) {
+        return generations
+            .map((generation) => this.generationToString(generation))
+            .reduce((previousValue, currentValue) => `${previousValue}${currentValue}`);
+    }
+    annotateSegment(text, grounding, support, index) {
+        const start = support.segment.startIndex ?? 0;
+        const end = support.segment.endIndex;
+        const textBefore = text.substring(0, start);
+        const textSegment = text.substring(start, end);
+        const textAfter = text.substring(end);
+        const textPrefix = this.segmentPrefix(grounding, support, index) ?? "";
+        const textSuffix = this.segmentSuffix(grounding, support, index) ?? "";
+        return `${textBefore}${textPrefix}${textSegment}${textSuffix}${textAfter}`;
+    }
+    annotateTextSegments(text, grounding) {
+        // Go through each support info in reverse, since the segment info
+        // is sorted, and we won't need to adjust string indexes this way.
+        let ret = text;
+        for (let co = grounding.supports.length - 1; co >= 0; co -= 1) {
+            const support = grounding.supports[co];
+            ret = this.annotateSegment(ret, grounding, support, co);
+        }
+        return ret;
+    }
+    /**
+     * Google requires us to
+     * "Display the Search Suggestion exactly as provided without any modifications"
+     * So this will typically be called from the textSuffix() method to get
+     * a string that renders HTML.
+     * See https://ai.google.dev/gemini-api/docs/grounding/search-suggestions
+     * @param grounding
+     */
+    searchSuggestion(grounding) {
+        return grounding.metadata.searchEntryPoint?.renderedContent ?? "";
+    }
+    annotateText(text, grounding) {
+        const prefix = this.textPrefix(text, grounding) ?? "";
+        const suffix = this.textSuffix(text, grounding) ?? "";
+        const body = this.annotateTextSegments(text, grounding);
+        return `${prefix}${body}${suffix}`;
+    }
+    async parseResult(generations, _callbacks) {
+        const text = this.generationsToString(generations);
+        const grounding = this.generationsToGroundingInfo(generations);
+        if (!grounding) {
+            return text;
+        }
+        return this.annotateText(text, grounding);
+    }
+}
+exports.BaseGoogleSearchOutputParser = BaseGoogleSearchOutputParser;
+class SimpleGoogleSearchOutputParser extends BaseGoogleSearchOutputParser {
+    segmentPrefix(_grounding, _support, _index) {
+        return undefined;
+    }
+    segmentSuffix(_grounding, support, _index) {
+        const indices = support.groundingChunkIndices.map((i) => i + 1);
+        return ` [${indices.join(", ")}]`;
+    }
+    textPrefix(_text, _grounding) {
+        return "Google Says:\n";
+    }
+    chunkToString(chunk, index) {
+        const info = chunk.retrievedContext ?? chunk.web;
+        return `${index + 1}. ${info.title} - ${info.uri}`;
+    }
+    textSuffix(_text, grounding) {
+        let ret = "\n";
+        const chunks = grounding.metadata.groundingChunks;
+        chunks.forEach((chunk, index) => {
+            ret = `${ret}${this.chunkToString(chunk, index)}\n`;
+        });
+        return ret;
+    }
+}
+exports.SimpleGoogleSearchOutputParser = SimpleGoogleSearchOutputParser;
+class MarkdownGoogleSearchOutputParser extends BaseGoogleSearchOutputParser {
+    segmentPrefix(_grounding, _support, _index) {
+        return undefined;
+    }
+    chunkLink(grounding, index) {
+        const chunk = grounding.metadata.groundingChunks[index];
+        const url = chunk.retrievedContext?.uri ?? chunk.web?.uri;
+        const num = index + 1;
+        return `[[${num}](${url})]`;
+    }
+    segmentSuffix(grounding, support, _index) {
+        let ret = "";
+        support.groundingChunkIndices.forEach((chunkIndex) => {
+            const link = this.chunkLink(grounding, chunkIndex);
+            ret = `${ret}${link}`;
+        });
+        return ret;
+    }
+    textPrefix(_text, _grounding) {
+        return undefined;
+    }
+    chunkSuffixLink(chunk, index) {
+        const num = index + 1;
+        const info = chunk.retrievedContext ?? chunk.web;
+        const url = info.uri;
+        const site = info.title;
+        return `${num}. [${site}](${url})`;
+    }
+    textSuffix(_text, grounding) {
+        let ret = "\n**Search Sources**\n";
+        const chunks = grounding.metadata.groundingChunks;
+        chunks.forEach((chunk, index) => {
+            ret = `${ret}${this.chunkSuffixLink(chunk, index)}\n`;
+        });
+        const search = this.searchSuggestion(grounding);
+        ret = `${ret}\n${search}`;
+        return ret;
+    }
+}
+exports.MarkdownGoogleSearchOutputParser = MarkdownGoogleSearchOutputParser;

package/dist/output_parsers.d.ts

@@ -0,0 +1,49 @@
+import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
+import { Callbacks } from "@langchain/core/callbacks/manager";
+import { ChatGeneration, Generation } from "@langchain/core/outputs";
+import { GeminiGroundingChunk, GeminiGroundingMetadata, GeminiGroundingSupport } from "./types.js";
+type Generations = Generation[] | ChatGeneration[];
+type GroundingInfo = {
+    metadata: GeminiGroundingMetadata;
+    supports: GeminiGroundingSupport[];
+};
+export declare abstract class BaseGoogleSearchOutputParser extends BaseLLMOutputParser<string> {
+    lc_namespace: string[];
+    protected generationToGroundingInfo(generation: Generation | ChatGeneration): GroundingInfo | undefined;
+    protected generationsToGroundingInfo(generations: Generations): GroundingInfo | undefined;
+    protected generationToString(generation: Generation | ChatGeneration): string;
+    protected generationsToString(generations: Generations): string;
+    protected abstract segmentPrefix(grounding: GroundingInfo, support: GeminiGroundingSupport, index: number): string | undefined;
+    protected abstract segmentSuffix(grounding: GroundingInfo, support: GeminiGroundingSupport, index: number): string | undefined;
+    protected annotateSegment(text: string, grounding: GroundingInfo, support: GeminiGroundingSupport, index: number): string;
+    protected annotateTextSegments(text: string, grounding: GroundingInfo): string;
+    protected abstract textPrefix(text: string, grounding: GroundingInfo): string | undefined;
+    protected abstract textSuffix(text: string, grounding: GroundingInfo): string | undefined;
+    /**
+     * Google requires us to
+     * "Display the Search Suggestion exactly as provided without any modifications"
+     * So this will typically be called from the textSuffix() method to get
+     * a string that renders HTML.
+     * See https://ai.google.dev/gemini-api/docs/grounding/search-suggestions
+     * @param grounding
+     */
+    protected searchSuggestion(grounding: GroundingInfo): string;
+    protected annotateText(text: string, grounding: GroundingInfo): string;
+    parseResult(generations: Generations, _callbacks?: Callbacks): Promise<string>;
+}
+export declare class SimpleGoogleSearchOutputParser extends BaseGoogleSearchOutputParser {
+    protected segmentPrefix(_grounding: GroundingInfo, _support: GeminiGroundingSupport, _index: number): string | undefined;
+    protected segmentSuffix(_grounding: GroundingInfo, support: GeminiGroundingSupport, _index: number): string | undefined;
+    protected textPrefix(_text: string, _grounding: GroundingInfo): string;
+    protected chunkToString(chunk: GeminiGroundingChunk, index: number): string;
+    protected textSuffix(_text: string, grounding: GroundingInfo): string;
+}
+export declare class MarkdownGoogleSearchOutputParser extends BaseGoogleSearchOutputParser {
+    protected segmentPrefix(_grounding: GroundingInfo, _support: GeminiGroundingSupport, _index: number): string | undefined;
+    protected chunkLink(grounding: GroundingInfo, index: number): string;
+    protected segmentSuffix(grounding: GroundingInfo, support: GeminiGroundingSupport, _index: number): string | undefined;
+    protected textPrefix(_text: string, _grounding: GroundingInfo): string | undefined;
+    protected chunkSuffixLink(chunk: GeminiGroundingChunk, index: number): string;
+    protected textSuffix(_text: string, grounding: GroundingInfo): string | undefined;
+}
+export {};

package/dist/output_parsers.js

@@ -0,0 +1,169 @@
+import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
+export class BaseGoogleSearchOutputParser extends BaseLLMOutputParser {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["google_common", "output_parsers"]
+        });
+    }
+    generationToGroundingInfo(generation) {
+        if ("message" in generation) {
+            const responseMetadata = generation?.message?.response_metadata;
+            const metadata = responseMetadata.groundingMetadata;
+            const supports = responseMetadata.groundingSupport ?? metadata.groundingSupports ?? [];
+            if (metadata) {
+                return {
+                    metadata,
+                    supports,
+                };
+            }
+        }
+        return undefined;
+    }
+    generationsToGroundingInfo(generations) {
+        for (const generation of generations) {
+            const info = this.generationToGroundingInfo(generation);
+            if (info !== undefined) {
+                return info;
+            }
+        }
+        return undefined;
+    }
+    generationToString(generation) {
+        if ("message" in generation) {
+            const content = generation?.message?.content;
+            if (typeof content === "string") {
+                return content;
+            }
+            else {
+                return content
+                    .map((c) => {
+                    if (c?.type === "text") {
+                        return c?.text ?? "";
+                    }
+                    else {
+                        return "";
+                    }
+                })
+                    .reduce((previousValue, currentValue) => `${previousValue}${currentValue}`);
+            }
+        }
+        return generation.text;
+    }
+    generationsToString(generations) {
+        return generations
+            .map((generation) => this.generationToString(generation))
+            .reduce((previousValue, currentValue) => `${previousValue}${currentValue}`);
+    }
+    annotateSegment(text, grounding, support, index) {
+        const start = support.segment.startIndex ?? 0;
+        const end = support.segment.endIndex;
+        const textBefore = text.substring(0, start);
+        const textSegment = text.substring(start, end);
+        const textAfter = text.substring(end);
+        const textPrefix = this.segmentPrefix(grounding, support, index) ?? "";
+        const textSuffix = this.segmentSuffix(grounding, support, index) ?? "";
+        return `${textBefore}${textPrefix}${textSegment}${textSuffix}${textAfter}`;
+    }
+    annotateTextSegments(text, grounding) {
+        // Go through each support info in reverse, since the segment info
+        // is sorted, and we won't need to adjust string indexes this way.
+        let ret = text;
+        for (let co = grounding.supports.length - 1; co >= 0; co -= 1) {
+            const support = grounding.supports[co];
+            ret = this.annotateSegment(ret, grounding, support, co);
+        }
+        return ret;
+    }
+    /**
+     * Google requires us to
+     * "Display the Search Suggestion exactly as provided without any modifications"
+     * So this will typically be called from the textSuffix() method to get
+     * a string that renders HTML.
+     * See https://ai.google.dev/gemini-api/docs/grounding/search-suggestions
+     * @param grounding
+     */
+    searchSuggestion(grounding) {
+        return grounding.metadata.searchEntryPoint?.renderedContent ?? "";
+    }
+    annotateText(text, grounding) {
+        const prefix = this.textPrefix(text, grounding) ?? "";
+        const suffix = this.textSuffix(text, grounding) ?? "";
+        const body = this.annotateTextSegments(text, grounding);
+        return `${prefix}${body}${suffix}`;
+    }
+    async parseResult(generations, _callbacks) {
+        const text = this.generationsToString(generations);
+        const grounding = this.generationsToGroundingInfo(generations);
+        if (!grounding) {
+            return text;
+        }
+        return this.annotateText(text, grounding);
+    }
+}
+export class SimpleGoogleSearchOutputParser extends BaseGoogleSearchOutputParser {
+    segmentPrefix(_grounding, _support, _index) {
+        return undefined;
+    }
+    segmentSuffix(_grounding, support, _index) {
+        const indices = support.groundingChunkIndices.map((i) => i + 1);
+        return ` [${indices.join(", ")}]`;
+    }
+    textPrefix(_text, _grounding) {
+        return "Google Says:\n";
+    }
+    chunkToString(chunk, index) {
+        const info = chunk.retrievedContext ?? chunk.web;
+        return `${index + 1}. ${info.title} - ${info.uri}`;
+    }
+    textSuffix(_text, grounding) {
+        let ret = "\n";
+        const chunks = grounding.metadata.groundingChunks;
+        chunks.forEach((chunk, index) => {
+            ret = `${ret}${this.chunkToString(chunk, index)}\n`;
+        });
+        return ret;
+    }
+}
+export class MarkdownGoogleSearchOutputParser extends BaseGoogleSearchOutputParser {
+    segmentPrefix(_grounding, _support, _index) {
+        return undefined;
+    }
+    chunkLink(grounding, index) {
+        const chunk = grounding.metadata.groundingChunks[index];
+        const url = chunk.retrievedContext?.uri ?? chunk.web?.uri;
+        const num = index + 1;
+        return `[[${num}](${url})]`;
+    }
+    segmentSuffix(grounding, support, _index) {
+        let ret = "";
+        support.groundingChunkIndices.forEach((chunkIndex) => {
+            const link = this.chunkLink(grounding, chunkIndex);
+            ret = `${ret}${link}`;
+        });
+        return ret;
+    }
+    textPrefix(_text, _grounding) {
+        return undefined;
+    }
+    chunkSuffixLink(chunk, index) {
+        const num = index + 1;
+        const info = chunk.retrievedContext ?? chunk.web;
+        const url = info.uri;
+        const site = info.title;
+        return `${num}. [${site}](${url})`;
+    }
+    textSuffix(_text, grounding) {
+        let ret = "\n**Search Sources**\n";
+        const chunks = grounding.metadata.groundingChunks;
+        chunks.forEach((chunk, index) => {
+            ret = `${ret}${this.chunkSuffixLink(chunk, index)}\n`;
+        });
+        const search = this.searchSuggestion(grounding);
+        ret = `${ret}\n${search}`;
+        return ret;
+    }
+}

package/dist/types.cjs

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GoogleAISafetyMethod = exports.GoogleAISafetyThreshold = exports.GoogleAISafetyCategory = void 0;
+exports.GeminiToolAttributes = exports.GeminiSearchToolAttributes = exports.GoogleAISafetyMethod = exports.GoogleAISafetyThreshold = exports.GoogleAISafetyCategory = void 0;
 __exportStar(require("./types-anthropic.cjs"), exports);
 exports.GoogleAISafetyCategory = {
     Harassment: "HARM_CATEGORY_HARASSMENT",
@@ -54,3 +54,12 @@ exports.GoogleAISafetyMethod = {
     Severity: "SEVERITY",
     Probability: "PROBABILITY",
 };
+exports.GeminiSearchToolAttributes = [
+    "googleSearchRetrieval",
+    "googleSearch",
+];
+exports.GeminiToolAttributes = [
+    "functionDeclaration",
+    "retrieval",
+    ...exports.GeminiSearchToolAttributes,
+];

package/dist/types.d.ts

@@ -219,6 +219,60 @@ export type GeminiSafetyRating = {
     category: string;
     probability: string;
 } & Record<string, unknown>;
+export interface GeminiCitationMetadata {
+    citations: GeminiCitation[];
+}
+export interface GeminiCitation {
+    startIndex: number;
+    endIndex: number;
+    uri: string;
+    title: string;
+    license: string;
+    publicationDate: GoogleTypeDate;
+}
+export interface GoogleTypeDate {
+    year: number;
+    month: number;
+    day: number;
+}
+export interface GeminiGroundingMetadata {
+    webSearchQueries?: string[];
+    searchEntryPoint?: GeminiSearchEntryPoint;
+    groundingChunks: GeminiGroundingChunk[];
+    groundingSupports?: GeminiGroundingSupport[];
+    retrievalMetadata?: GeminiRetrievalMetadata;
+}
+export interface GeminiSearchEntryPoint {
+    renderedContent?: string;
+    sdkBlob?: string;
+}
+export interface GeminiGroundingChunk {
+    web: GeminiGroundingChunkWeb;
+    retrievedContext: GeminiGroundingChunkRetrievedContext;
+}
+export interface GeminiGroundingChunkWeb {
+    uri: string;
+    title: string;
+}
+export interface GeminiGroundingChunkRetrievedContext {
+    uri: string;
+    title: string;
+    text: string;
+}
+export interface GeminiGroundingSupport {
+    segment: GeminiSegment;
+    groundingChunkIndices: number[];
+    confidenceScores: number[];
+}
+export interface GeminiSegment {
+    partIndex: number;
+    startIndex: number;
+    endIndex: number;
+    text: string;
+}
+export interface GeminiRetrievalMetadata {
+    googleSearchDynamicRetrievalScore: number;
+}
 export type GeminiRole = "system" | "user" | "model" | "function";
 export interface GeminiContent {
     parts: GeminiPart[];
@@ -227,14 +281,20 @@ export interface GeminiContent {
 export interface GeminiTool {
     functionDeclarations?: GeminiFunctionDeclaration[];
     googleSearchRetrieval?: GoogleSearchRetrieval;
+    googleSearch?: GoogleSearch;
     retrieval?: VertexAIRetrieval;
 }
+export type GoogleSearchToolSetting = boolean | "googleSearchRetrieval" | "googleSearch" | string;
+export declare const GeminiSearchToolAttributes: string[];
+export declare const GeminiToolAttributes: string[];
 export interface GoogleSearchRetrieval {
     dynamicRetrievalConfig?: {
         mode?: string;
         dynamicThreshold?: number;
     };
 }
+export interface GoogleSearch {
+}
 export interface VertexAIRetrieval {
     vertexAiSearch: {
         datastore: string;
@@ -288,6 +348,8 @@ interface GeminiResponseCandidate {
     index: number;
     tokenCount?: number;
     safetyRatings: GeminiSafetyRating[];
+    citationMetadata?: GeminiCitationMetadata;
+    groundingMetadata?: GeminiGroundingMetadata;
 }
 interface GeminiResponsePromptFeedback {
     blockReason?: string;
@@ -339,6 +401,17 @@ export interface GeminiAPIConfig {
     safetyHandler?: GoogleAISafetyHandler;
     mediaManager?: MediaManager;
     useSystemInstruction?: boolean;
+    /**
+     * How to handle the Google Search tool, since the name (and format)
+     * of the tool changes between Gemini 1.5 and Gemini 2.0.
+     * true - Change based on the model version. (Default)
+     * false - Do not change the tool name provided
+     * string value - Use this as the attribute name for the search
+     *   tool, adapting any tool attributes if possible.
+     * When the model is created, a "true" or default setting
+     * will be changed to a string based on the model.
+     */
+    googleSearchToolAdjustment?: GoogleSearchToolSetting;
 }
 export type GoogleAIAPIConfig = GeminiAPIConfig | AnthropicAPIConfig;
 export interface GoogleAIAPIParams {

package/dist/types.js

@@ -37,3 +37,12 @@ export const GoogleAISafetyMethod = {
     Severity: "SEVERITY",
     Probability: "PROBABILITY",
 };
+export const GeminiSearchToolAttributes = [
+    "googleSearchRetrieval",
+    "googleSearch",
+];
+export const GeminiToolAttributes = [
+    "functionDeclaration",
+    "retrieval",
+    ...GeminiSearchToolAttributes,
+];

package/dist/utils/common.cjs

@@ -4,6 +4,7 @@ exports.copyAndValidateModelParamsInto = exports.validateModelParams = exports.m
 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 types_js_1 = require("../types.cjs");
 const zod_to_gemini_parameters_js_1 = require("./zod_to_gemini_parameters.cjs");
 const anthropic_js_1 = require("./anthropic.cjs");
 function copyAIModelParams(params, options) {
@@ -37,11 +38,22 @@ function processToolChoice(toolChoice, allowedFunctionNames) {
     }
     throw new Error("Object inputs for tool_choice not supported.");
 }
+function isGeminiTool(tool) {
+    for (const toolAttribute of types_js_1.GeminiToolAttributes) {
+        if (toolAttribute in tool) {
+            return true;
+        }
+    }
+    return false;
+}
+function isGeminiNonFunctionTool(tool) {
+    return isGeminiTool(tool) && !("functionDeclaration" in tool);
+}
 function convertToGeminiTools(tools) {
     const geminiTools = [];
     let functionDeclarationsIndex = -1;
     tools.forEach((tool) => {
-        if ("googleSearchRetrieval" in tool || "retrieval" in tool) {
+        if (isGeminiNonFunctionTool(tool)) {
             geminiTools.push(tool);
         }
         else {

package/dist/utils/common.d.ts

@@ -1,4 +1,4 @@
-import type { GeminiTool, GoogleAIBaseLanguageModelCallOptions, GoogleAIModelParams, GoogleAIModelRequestParams, GoogleAIToolType, VertexModelFamily } from "../types.js";
+import { GeminiTool, GoogleAIBaseLanguageModelCallOptions, GoogleAIModelParams, GoogleAIModelRequestParams, GoogleAIToolType, VertexModelFamily } from "../types.js";
 export declare function copyAIModelParams(params: GoogleAIModelParams | undefined, options: GoogleAIBaseLanguageModelCallOptions | undefined): GoogleAIModelRequestParams;
 export declare function convertToGeminiTools(tools: GoogleAIToolType[]): GeminiTool[];
 export declare function copyAIModelParamsInto(params: GoogleAIModelParams | undefined, options: GoogleAIBaseLanguageModelCallOptions | undefined, target: GoogleAIModelParams): GoogleAIModelRequestParams;

package/dist/utils/common.js

@@ -1,6 +1,7 @@
 import { isOpenAITool } from "@langchain/core/language_models/base";
 import { isLangChainTool } from "@langchain/core/utils/function_calling";
 import { isModelGemini, validateGeminiParams } from "./gemini.js";
+import { GeminiToolAttributes, } from "../types.js";
 import { jsonSchemaToGeminiParameters, zodToGeminiParameters, } from "./zod_to_gemini_parameters.js";
 import { isModelClaude, validateClaudeParams } from "./anthropic.js";
 export function copyAIModelParams(params, options) {
@@ -33,11 +34,22 @@ function processToolChoice(toolChoice, allowedFunctionNames) {
     }
     throw new Error("Object inputs for tool_choice not supported.");
 }
+function isGeminiTool(tool) {
+    for (const toolAttribute of GeminiToolAttributes) {
+        if (toolAttribute in tool) {
+            return true;
+        }
+    }
+    return false;
+}
+function isGeminiNonFunctionTool(tool) {
+    return isGeminiTool(tool) && !("functionDeclaration" in tool);
+}
 export function convertToGeminiTools(tools) {
     const geminiTools = [];
     let functionDeclarationsIndex = -1;
     tools.forEach((tool) => {
-        if ("googleSearchRetrieval" in tool || "retrieval" in tool) {
+        if (isGeminiNonFunctionTool(tool)) {
             geminiTools.push(tool);
         }
         else {

package/dist/utils/gemini.cjs

@@ -6,6 +6,7 @@ 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 safety_js_1 = require("./safety.cjs");
+const types_js_1 = require("../types.cjs");
 const zod_to_gemini_parameters_js_1 = require("./zod_to_gemini_parameters.cjs");
 class DefaultGeminiSafetyHandler {
     constructor(settings) {
@@ -523,6 +524,8 @@ function getGeminiAPI(config) {
                 severity: rating.severity,
                 severity_score: rating.severityScore,
             })),
+            citation_metadata: data.candidates[0]?.citationMetadata,
+            grounding_metadata: data.candidates[0]?.groundingMetadata,
             finish_reason: data.candidates[0]?.finishReason,
         };
     }
@@ -577,12 +580,59 @@ function getGeminiAPI(config) {
             message,
         });
     }
-    function responseToChatGenerations(response) {
+    function groundingSupportByPart(groundingSupports) {
+        const ret = [];
+        if (!groundingSupports || groundingSupports.length === 0) {
+            return [];
+        }
+        groundingSupports?.forEach((groundingSupport) => {
+            const segment = groundingSupport?.segment;
+            const partIndex = segment?.partIndex ?? 0;
+            if (ret[partIndex]) {
+                ret[partIndex].push(groundingSupport);
+            }
+            else {
+                ret[partIndex] = [groundingSupport];
+            }
+        });
+        return ret;
+    }
+    function responseToGroundedChatGenerations(response) {
         const parts = responseToParts(response);
         if (parts.length === 0) {
             return [];
         }
-        let ret = parts.map((part) => partToChatGeneration(part));
+        // Citation and grounding information connected to each part / ChatGeneration
+        // to make sure they are available in downstream filters.
+        const candidate = response?.data
+            ?.candidates?.[0];
+        const groundingMetadata = candidate?.groundingMetadata;
+        const citationMetadata = candidate?.citationMetadata;
+        const groundingParts = groundingSupportByPart(groundingMetadata?.groundingSupports);
+        const ret = parts.map((part, index) => {
+            const gen = partToChatGeneration(part);
+            if (!gen.generationInfo) {
+                gen.generationInfo = {};
+            }
+            if (groundingMetadata) {
+                gen.generationInfo.groundingMetadata = groundingMetadata;
+                const groundingPart = groundingParts[index];
+                if (groundingPart) {
+                    gen.generationInfo.groundingSupport = groundingPart;
+                }
+            }
+            if (citationMetadata) {
+                gen.generationInfo.citationMetadata = citationMetadata;
+            }
+            return gen;
+        });
+        return ret;
+    }
+    function responseToChatGenerations(response) {
+        let ret = responseToGroundedChatGenerations(response);
+        if (ret.length === 0) {
+            return [];
+        }
         if (ret.every((item) => typeof item.message.content === "string")) {
             const combinedContent = ret.map((item) => item.message.content).join("");
             const combinedText = ret.map((item) => item.text).join("");
@@ -788,14 +838,43 @@ function getGeminiAPI(config) {
             parameters: jsonSchema,
         };
     }
+    function searchToolName(tool) {
+        for (const name of types_js_1.GeminiSearchToolAttributes) {
+            if (name in tool) {
+                return name;
+            }
+        }
+        return undefined;
+    }
+    function cleanGeminiTool(tool) {
+        const orig = searchToolName(tool);
+        const adj = config?.googleSearchToolAdjustment;
+        if (orig && adj && adj !== orig) {
+            return {
+                [adj]: {},
+            };
+        }
+        else {
+            return tool;
+        }
+    }
     function formatTools(parameters) {
         const tools = parameters?.tools;
         if (!tools || tools.length === 0) {
             return [];
         }
-        // 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));
+        // Group all LangChain tools into a single functionDeclarations array.
+        // Gemini Tools may be normalized to different tool names
+        const langChainTools = [];
+        const otherTools = [];
+        tools.forEach((tool) => {
+            if ((0, function_calling_1.isLangChainTool)(tool)) {
+                langChainTools.push(tool);
+            }
+            else {
+                otherTools.push(cleanGeminiTool(tool));
+            }
+        });
         const result = [...otherTools];
         if (langChainTools.length > 0) {
             result.push({
@@ -808,10 +887,19 @@ function getGeminiAPI(config) {
         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

@@ -3,6 +3,7 @@ import { AIMessage, AIMessageChunk, isAIMessage, } from "@langchain/core/message
 import { ChatGenerationChunk, } from "@langchain/core/outputs";
 import { isLangChainTool } from "@langchain/core/utils/function_calling";
 import { GoogleAISafetyError } from "./safety.js";
+import { GeminiSearchToolAttributes, } from "../types.js";
 import { zodToGeminiParameters } from "./zod_to_gemini_parameters.js";
 export class DefaultGeminiSafetyHandler {
     constructor(settings) {
@@ -518,6 +519,8 @@ export function getGeminiAPI(config) {
                 severity: rating.severity,
                 severity_score: rating.severityScore,
             })),
+            citation_metadata: data.candidates[0]?.citationMetadata,
+            grounding_metadata: data.candidates[0]?.groundingMetadata,
             finish_reason: data.candidates[0]?.finishReason,
         };
     }
@@ -572,12 +575,59 @@ export function getGeminiAPI(config) {
             message,
         });
     }
-    function responseToChatGenerations(response) {
+    function groundingSupportByPart(groundingSupports) {
+        const ret = [];
+        if (!groundingSupports || groundingSupports.length === 0) {
+            return [];
+        }
+        groundingSupports?.forEach((groundingSupport) => {
+            const segment = groundingSupport?.segment;
+            const partIndex = segment?.partIndex ?? 0;
+            if (ret[partIndex]) {
+                ret[partIndex].push(groundingSupport);
+            }
+            else {
+                ret[partIndex] = [groundingSupport];
+            }
+        });
+        return ret;
+    }
+    function responseToGroundedChatGenerations(response) {
         const parts = responseToParts(response);
         if (parts.length === 0) {
             return [];
         }
-        let ret = parts.map((part) => partToChatGeneration(part));
+        // Citation and grounding information connected to each part / ChatGeneration
+        // to make sure they are available in downstream filters.
+        const candidate = response?.data
+            ?.candidates?.[0];
+        const groundingMetadata = candidate?.groundingMetadata;
+        const citationMetadata = candidate?.citationMetadata;
+        const groundingParts = groundingSupportByPart(groundingMetadata?.groundingSupports);
+        const ret = parts.map((part, index) => {
+            const gen = partToChatGeneration(part);
+            if (!gen.generationInfo) {
+                gen.generationInfo = {};
+            }
+            if (groundingMetadata) {
+                gen.generationInfo.groundingMetadata = groundingMetadata;
+                const groundingPart = groundingParts[index];
+                if (groundingPart) {
+                    gen.generationInfo.groundingSupport = groundingPart;
+                }
+            }
+            if (citationMetadata) {
+                gen.generationInfo.citationMetadata = citationMetadata;
+            }
+            return gen;
+        });
+        return ret;
+    }
+    function responseToChatGenerations(response) {
+        let ret = responseToGroundedChatGenerations(response);
+        if (ret.length === 0) {
+            return [];
+        }
         if (ret.every((item) => typeof item.message.content === "string")) {
             const combinedContent = ret.map((item) => item.message.content).join("");
             const combinedText = ret.map((item) => item.text).join("");
@@ -783,14 +833,43 @@ export function getGeminiAPI(config) {
             parameters: jsonSchema,
         };
     }
+    function searchToolName(tool) {
+        for (const name of GeminiSearchToolAttributes) {
+            if (name in tool) {
+                return name;
+            }
+        }
+        return undefined;
+    }
+    function cleanGeminiTool(tool) {
+        const orig = searchToolName(tool);
+        const adj = config?.googleSearchToolAdjustment;
+        if (orig && adj && adj !== orig) {
+            return {
+                [adj]: {},
+            };
+        }
+        else {
+            return tool;
+        }
+    }
     function formatTools(parameters) {
         const tools = parameters?.tools;
         if (!tools || tools.length === 0) {
             return [];
         }
-        // Group all LangChain tools into a single functionDeclarations array
-        const langChainTools = tools.filter(isLangChainTool);
-        const otherTools = tools.filter((tool) => !isLangChainTool(tool));
+        // Group all LangChain tools into a single functionDeclarations array.
+        // Gemini Tools may be normalized to different tool names
+        const langChainTools = [];
+        const otherTools = [];
+        tools.forEach((tool) => {
+            if (isLangChainTool(tool)) {
+                langChainTools.push(tool);
+            }
+            else {
+                otherTools.push(cleanGeminiTool(tool));
+            }
+        });
         const result = [...otherTools];
         if (langChainTools.length > 0) {
             result.push({
@@ -803,10 +882,19 @@ export function getGeminiAPI(config) {
         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.4",
+  "version": "0.1.6",
   "description": "Core types and classes for Google services.",
   "type": "module",
   "engines": {