@langchain/google-common 0.1.5 → 0.1.7

package/dist/types.d.ts

@@ -118,6 +118,34 @@ export interface GoogleAIModelParams {
      * among the 3 most probable tokens (using temperature).
      */
     topK?: number;
+    /**
+     * Presence penalty applied to the next token's logprobs
+     * if the token has already been seen in the response.
+     * This penalty is binary on/off and not dependant on the
+     * number of times the token is used (after the first).
+     * Use frequencyPenalty for a penalty that increases with each use.
+     * A positive penalty will discourage the use of tokens that have
+     * already been used in the response, increasing the vocabulary.
+     * A negative penalty will encourage the use of tokens that have
+     * already been used in the response, decreasing the vocabulary.
+     */
+    presencePenalty?: number;
+    /**
+     * Frequency penalty applied to the next token's logprobs,
+     * multiplied by the number of times each token has been seen
+     * in the respponse so far.
+     * A positive penalty will discourage the use of tokens that
+     * have already been used, proportional to the number of times
+     * the token has been used:
+     * The more a token is used, the more dificult it is for the model
+     * to use that token again increasing the vocabulary of responses.
+     * Caution: A _negative_ penalty will encourage the model to reuse
+     * tokens proportional to the number of times the token has been used.
+     * Small negative values will reduce the vocabulary of a response.
+     * Larger negative values will cause the model to start repeating
+     * a common token until it hits the maxOutputTokens limit.
+     */
+    frequencyPenalty?: number;
     stopSequences?: string[];
     safetySettings?: GoogleAISafetySetting[];
     convertSystemMessageToHumanContent?: boolean;
@@ -136,6 +164,19 @@ export interface GoogleAIModelParams {
      * @default false
      */
     streaming?: boolean;
+    /**
+     * Whether to return log probabilities of the output tokens or not.
+     * If true, returns the log probabilities of each output token
+     * returned in the content of message.
+     */
+    logprobs?: boolean;
+    /**
+     * An integer between 0 and 5 specifying the number of
+     * most likely tokens to return at each token position,
+     * each with an associated log probability.
+     * logprobs must be set to true if this parameter is used.
+     */
+    topLogprobs?: number;
 }
 export type GoogleAIToolType = BindToolsInput | GeminiTool;
 /**
@@ -219,6 +260,72 @@ 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 interface GeminiLogprobsResult {
+    topCandidates: GeminiLogprobsTopCandidate[];
+    chosenCandidates: GeminiLogprobsResultCandidate[];
+}
+export interface GeminiLogprobsTopCandidate {
+    candidates: GeminiLogprobsResultCandidate[];
+}
+export interface GeminiLogprobsResultCandidate {
+    token: string;
+    tokenId: number;
+    logProbability: number;
+}
 export type GeminiRole = "system" | "user" | "model" | "function";
 export interface GeminiContent {
     parts: GeminiPart[];
@@ -227,14 +334,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;
@@ -264,7 +377,11 @@ export interface GeminiGenerationConfig {
     temperature?: number;
     topP?: number;
     topK?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
     responseMimeType?: GoogleAIResponseMimeType;
+    responseLogprobs?: boolean;
+    logprobs?: number;
 }
 export interface GeminiRequest {
     contents?: GeminiContent[];
@@ -279,7 +396,7 @@ export interface GeminiRequest {
     safetySettings?: GeminiSafetySetting[];
     generationConfig?: GeminiGenerationConfig;
 }
-interface GeminiResponseCandidate {
+export interface GeminiResponseCandidate {
     content: {
         parts: GeminiPart[];
         role: string;
@@ -288,6 +405,10 @@ interface GeminiResponseCandidate {
     index: number;
     tokenCount?: number;
     safetyRatings: GeminiSafetyRating[];
+    citationMetadata?: GeminiCitationMetadata;
+    groundingMetadata?: GeminiGroundingMetadata;
+    avgLogprobs?: number;
+    logprobsResult: GeminiLogprobsResult;
 }
 interface GeminiResponsePromptFeedback {
     blockReason?: string;
@@ -339,6 +460,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 {
@@ -93,10 +105,21 @@ function copyAIModelParamsInto(params, options, target) {
             target.maxOutputTokens;
     ret.topP = options?.topP ?? params?.topP ?? target.topP;
     ret.topK = options?.topK ?? params?.topK ?? target.topK;
+    ret.presencePenalty =
+        options?.presencePenalty ??
+            params?.presencePenalty ??
+            target.presencePenalty;
+    ret.frequencyPenalty =
+        options?.frequencyPenalty ??
+            params?.frequencyPenalty ??
+            target.frequencyPenalty;
     ret.stopSequences =
         options?.stopSequences ?? params?.stopSequences ?? target.stopSequences;
     ret.safetySettings =
         options?.safetySettings ?? params?.safetySettings ?? target.safetySettings;
+    ret.logprobs = options?.logprobs ?? params?.logprobs ?? target.logprobs;
+    ret.topLogprobs =
+        options?.topLogprobs ?? params?.topLogprobs ?? target.topLogprobs;
     ret.convertSystemMessageToHumanContent =
         options?.convertSystemMessageToHumanContent ??
             params?.convertSystemMessageToHumanContent ??

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 {
@@ -88,10 +100,21 @@ export function copyAIModelParamsInto(params, options, target) {
             target.maxOutputTokens;
     ret.topP = options?.topP ?? params?.topP ?? target.topP;
     ret.topK = options?.topK ?? params?.topK ?? target.topK;
+    ret.presencePenalty =
+        options?.presencePenalty ??
+            params?.presencePenalty ??
+            target.presencePenalty;
+    ret.frequencyPenalty =
+        options?.frequencyPenalty ??
+            params?.frequencyPenalty ??
+            target.frequencyPenalty;
     ret.stopSequences =
         options?.stopSequences ?? params?.stopSequences ?? target.stopSequences;
     ret.safetySettings =
         options?.safetySettings ?? params?.safetySettings ?? target.safetySettings;
+    ret.logprobs = options?.logprobs ?? params?.logprobs ?? target.logprobs;
+    ret.topLogprobs =
+        options?.topLogprobs ?? params?.topLogprobs ?? target.topLogprobs;
     ret.convertSystemMessageToHumanContent =
         options?.convertSystemMessageToHumanContent ??
             params?.convertSystemMessageToHumanContent ??

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) {
@@ -505,6 +506,33 @@ function getGeminiAPI(config) {
     function safeResponseToString(response) {
         return safeResponseTo(response, responseToString);
     }
+    function logprobResultToLogprob(result) {
+        const token = result?.token;
+        const logprob = result?.logProbability;
+        const encoder = new TextEncoder();
+        const bytes = Array.from(encoder.encode(token));
+        return {
+            token,
+            logprob,
+            bytes,
+        };
+    }
+    function candidateToLogprobs(candidate) {
+        const logprobs = candidate?.logprobsResult;
+        const chosenTokens = logprobs?.chosenCandidates ?? [];
+        const topTokens = logprobs?.topCandidates ?? [];
+        const content = [];
+        for (let co = 0; co < chosenTokens.length; co += 1) {
+            const chosen = chosenTokens[co];
+            const top = topTokens[co]?.candidates ?? [];
+            const logprob = logprobResultToLogprob(chosen);
+            logprob.top_logprobs = top.map((l) => logprobResultToLogprob(l));
+            content.push(logprob);
+        }
+        return {
+            content,
+        };
+    }
     function responseToGenerationInfo(response) {
         if (!Array.isArray(response.data)) {
             return {};
@@ -523,7 +551,11 @@ 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,
+            avgLogprobs: data.candidates[0]?.avgLogprobs,
+            logprobs: candidateToLogprobs(data.candidates[0]),
         };
     }
     function responseToChatGeneration(response) {
@@ -577,12 +609,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("");
@@ -615,6 +694,18 @@ function getGeminiAPI(config) {
                 }),
             ];
         }
+        // Add logprobs information to the message
+        const candidate = response?.data
+            ?.candidates?.[0];
+        const avgLogprobs = candidate?.avgLogprobs;
+        const logprobs = candidateToLogprobs(candidate);
+        if (logprobs) {
+            ret[0].message.response_metadata = {
+                ...ret[0].message.response_metadata,
+                logprobs,
+                avgLogprobs,
+            };
+        }
         return ret;
     }
     function responseToBaseMessageFields(response) {
@@ -742,9 +833,13 @@ function getGeminiAPI(config) {
             temperature: parameters.temperature,
             topK: parameters.topK,
             topP: parameters.topP,
+            presencePenalty: parameters.presencePenalty,
+            frequencyPenalty: parameters.frequencyPenalty,
             maxOutputTokens: parameters.maxOutputTokens,
             stopSequences: parameters.stopSequences,
             responseMimeType: parameters.responseMimeType,
+            responseLogprobs: parameters.logprobs,
+            logprobs: parameters.topLogprobs,
         };
     }
     function formatSafetySettings(parameters) {
@@ -788,14 +883,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({