@langchain/google-common 0.1.5 → 0.1.7

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) {
@@ -500,6 +501,33 @@ export 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 {};
@@ -518,7 +546,11 @@ 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,
+            avgLogprobs: data.candidates[0]?.avgLogprobs,
+            logprobs: candidateToLogprobs(data.candidates[0]),
         };
     }
     function responseToChatGeneration(response) {
@@ -572,12 +604,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("");
@@ -610,6 +689,18 @@ export 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) {
@@ -737,9 +828,13 @@ export 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) {
@@ -783,14 +878,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({

package/package.json

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