@langchain/google-common 0.1.8 → 0.2.0

package/dist/chat_models.cjs

@@ -131,25 +131,25 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 0.7
+            value: void 0
         });
         Object.defineProperty(this, "maxOutputTokens", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 1024
+            value: void 0
         });
         Object.defineProperty(this, "topP", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 0.8
+            value: void 0
         });
         Object.defineProperty(this, "topK", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 40
+            value: void 0
         });
         Object.defineProperty(this, "presencePenalty", {
             enumerable: true,
@@ -246,13 +246,7 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
         return new auth_js_1.ApiKeyGoogleAuth(apiKey);
     }
     buildApiKey(fields) {
-        if (fields?.platformType !== "gcp") {
-            return fields?.apiKey ?? (0, env_1.getEnvironmentVariable)("GOOGLE_API_KEY");
-        }
-        else {
-            // GCP doesn't support API Keys
-            return undefined;
-        }
+        return fields?.apiKey ?? (0, env_1.getEnvironmentVariable)("GOOGLE_API_KEY");
     }
     buildClient(fields) {
         const apiKey = this.buildApiKey(fields);

package/dist/chat_models.js

@@ -127,25 +127,25 @@ export class ChatGoogleBase extends BaseChatModel {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 0.7
+            value: void 0
         });
         Object.defineProperty(this, "maxOutputTokens", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 1024
+            value: void 0
         });
         Object.defineProperty(this, "topP", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 0.8
+            value: void 0
         });
         Object.defineProperty(this, "topK", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 40
+            value: void 0
         });
         Object.defineProperty(this, "presencePenalty", {
             enumerable: true,
@@ -242,13 +242,7 @@ export class ChatGoogleBase extends BaseChatModel {
         return new ApiKeyGoogleAuth(apiKey);
     }
     buildApiKey(fields) {
-        if (fields?.platformType !== "gcp") {
-            return fields?.apiKey ?? getEnvironmentVariable("GOOGLE_API_KEY");
-        }
-        else {
-            // GCP doesn't support API Keys
-            return undefined;
-        }
+        return fields?.apiKey ?? getEnvironmentVariable("GOOGLE_API_KEY");
     }
     buildClient(fields) {
         const apiKey = this.buildApiKey(fields);

package/dist/connection.cjs

@@ -223,8 +223,14 @@ class GoogleAIConnection extends GoogleHostConnection {
                 throw new Error(`Unknown API: ${this.apiName}`);
         }
     }
+    get isApiKey() {
+        return this.client.clientType === "apiKey";
+    }
     get computedPlatformType() {
-        if (this.client.clientType === "apiKey") {
+        // This is not a completely correct assumption, since GCP can
+        // have an API Key. But if so, then people need to set the platform
+        // type explicitly.
+        if (this.isApiKey) {
             return "gai";
         }
         else {
@@ -246,13 +252,27 @@ class GoogleAIConnection extends GoogleHostConnection {
         const url = `https://generativelanguage.googleapis.com/${this.apiVersion}/models/${this.model}:${method}`;
         return url;
     }
-    async buildUrlVertex() {
+    async buildUrlVertexExpress() {
+        const method = await this.buildUrlMethod();
+        const publisher = this.modelPublisher;
+        const url = `https://aiplatform.googleapis.com/${this.apiVersion}/publishers/${publisher}/models/${this.model}:${method}`;
+        return url;
+    }
+    async buildUrlVertexLocation() {
         const projectId = await this.client.getProjectId();
         const method = await this.buildUrlMethod();
         const publisher = this.modelPublisher;
         const url = `https://${this.endpoint}/${this.apiVersion}/projects/${projectId}/locations/${this.location}/publishers/${publisher}/models/${this.model}:${method}`;
         return url;
     }
+    async buildUrlVertex() {
+        if (this.isApiKey) {
+            return this.buildUrlVertexExpress();
+        }
+        else {
+            return this.buildUrlVertexLocation();
+        }
+    }
     async buildUrl() {
         switch (this.platform) {
             case "gai":

package/dist/connection.d.ts

@@ -50,10 +50,13 @@ export declare abstract class GoogleAIConnection<CallOptions extends AsyncCaller
     get computedAPIName(): string;
     get apiName(): string;
     get api(): GoogleAIAPI;
+    get isApiKey(): boolean;
     get computedPlatformType(): GooglePlatformType;
     get computedLocation(): string;
     abstract buildUrlMethod(): Promise<string>;
     buildUrlGenerativeLanguage(): Promise<string>;
+    buildUrlVertexExpress(): Promise<string>;
+    buildUrlVertexLocation(): Promise<string>;
     buildUrlVertex(): Promise<string>;
     buildUrl(): Promise<string>;
     abstract formatData(input: InputType, parameters: GoogleAIModelRequestParams): Promise<unknown>;

package/dist/connection.js

@@ -217,8 +217,14 @@ export class GoogleAIConnection extends GoogleHostConnection {
                 throw new Error(`Unknown API: ${this.apiName}`);
         }
     }
+    get isApiKey() {
+        return this.client.clientType === "apiKey";
+    }
     get computedPlatformType() {
-        if (this.client.clientType === "apiKey") {
+        // This is not a completely correct assumption, since GCP can
+        // have an API Key. But if so, then people need to set the platform
+        // type explicitly.
+        if (this.isApiKey) {
             return "gai";
         }
         else {
@@ -240,13 +246,27 @@ export class GoogleAIConnection extends GoogleHostConnection {
         const url = `https://generativelanguage.googleapis.com/${this.apiVersion}/models/${this.model}:${method}`;
         return url;
     }
-    async buildUrlVertex() {
+    async buildUrlVertexExpress() {
+        const method = await this.buildUrlMethod();
+        const publisher = this.modelPublisher;
+        const url = `https://aiplatform.googleapis.com/${this.apiVersion}/publishers/${publisher}/models/${this.model}:${method}`;
+        return url;
+    }
+    async buildUrlVertexLocation() {
         const projectId = await this.client.getProjectId();
         const method = await this.buildUrlMethod();
         const publisher = this.modelPublisher;
         const url = `https://${this.endpoint}/${this.apiVersion}/projects/${projectId}/locations/${this.location}/publishers/${publisher}/models/${this.model}:${method}`;
         return url;
     }
+    async buildUrlVertex() {
+        if (this.isApiKey) {
+            return this.buildUrlVertexExpress();
+        }
+        else {
+            return this.buildUrlVertexLocation();
+        }
+    }
     async buildUrl() {
         switch (this.platform) {
             case "gai":

package/dist/utils/gemini.cjs

@@ -5,6 +5,7 @@ const uuid_1 = require("uuid");
 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 stream_1 = require("@langchain/core/utils/stream");
 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");
@@ -604,9 +605,12 @@ function getGeminiAPI(config) {
     function partToChatGeneration(part) {
         const message = partToMessageChunk(part);
         const text = partToText(part);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const generationInfo = {};
         return new outputs_1.ChatGenerationChunk({
             text,
             message,
+            generationInfo,
         });
     }
     function groundingSupportByPart(groundingSupports) {
@@ -657,43 +661,134 @@ function getGeminiAPI(config) {
         });
         return ret;
     }
+    function combineContent(gen, forceComplex = false) {
+        const allString = gen.every((item) => typeof item.message.content === "string");
+        if (allString && !forceComplex) {
+            // Everything is a string, and we don't want to force it to return
+            // MessageContentComplex[], so concatenate the content into one string
+            return gen.map((item) => item.message.content).join("");
+        }
+        else {
+            // We either have complex types, or we want to force them, so turn
+            // it into an array of complex types.
+            const ret = [];
+            gen.forEach((item) => {
+                if (typeof item.message.content === "string") {
+                    // If this is a string, turn it into a text type
+                    ret.push({
+                        text: item.message.content,
+                    });
+                }
+                else {
+                    // Otherwise, add all the complex types to what we're returning
+                    item.message.content.forEach((c) => {
+                        ret.push(c);
+                    });
+                }
+            });
+            return ret;
+        }
+    }
+    function combineText(gen) {
+        return gen.map((item) => item.text ?? "").join("");
+    }
+    /*
+     * We don't really need the entire AIMessageChunk here, but it is
+     * a conventient way to combine all the Tool Calling information.
+     */
+    function combineToolCalls(gen) {
+        let ret = new messages_1.AIMessageChunk("");
+        gen.forEach((item) => {
+            const message = item?.message;
+            ret = (0, stream_1.concat)(ret, message);
+        });
+        return ret;
+    }
+    function combineAdditionalKwargs(gen) {
+        const ret = {};
+        gen.forEach((item) => {
+            const message = item?.message;
+            const kwargs = message?.additional_kwargs ?? {};
+            const keys = Object.keys(kwargs);
+            keys.forEach((key) => {
+                const value = kwargs[key];
+                if (Object.hasOwn(ret, key) &&
+                    Array.isArray(ret[key]) &&
+                    Array.isArray(value)) {
+                    ret[key].push(...value);
+                }
+                else {
+                    ret[key] = value;
+                }
+            });
+        });
+        return ret;
+    }
+    function combineGenerations(generations, response) {
+        const gen = splitGenerationTypes(generations, response);
+        const combinedContent = combineContent(gen.content);
+        const combinedText = combineText(gen.content);
+        const combinedToolCalls = combineToolCalls(gen.content);
+        const kwargs = combineAdditionalKwargs(gen.content);
+        const lastContent = gen.content[gen.content.length - 1];
+        // Add usage metadata
+        let usageMetadata;
+        if ("usageMetadata" in response.data) {
+            usageMetadata = {
+                input_tokens: response.data.usageMetadata.promptTokenCount,
+                output_tokens: response.data.usageMetadata
+                    .candidatesTokenCount,
+                total_tokens: response.data.usageMetadata.totalTokenCount,
+            };
+        }
+        // Add thinking / reasoning
+        // if (gen.reasoning && gen.reasoning.length > 0) {
+        //   kwargs.reasoning_content = combineContent(gen.reasoning, true);
+        // }
+        // Build the message and the generation chunk to return
+        const message = new messages_1.AIMessageChunk({
+            content: combinedContent,
+            additional_kwargs: kwargs,
+            usage_metadata: usageMetadata,
+            tool_calls: combinedToolCalls.tool_calls,
+            invalid_tool_calls: combinedToolCalls.invalid_tool_calls,
+        });
+        return [
+            new outputs_1.ChatGenerationChunk({
+                message,
+                text: combinedText,
+                generationInfo: lastContent.generationInfo,
+            }),
+        ];
+    }
+    function splitGenerationTypes(generations, _response) {
+        const content = [];
+        const reasoning = [];
+        generations.forEach((gen) => {
+            if (gen?.generationInfo?.thought) {
+                reasoning.push(gen);
+            }
+            else {
+                content.push(gen);
+            }
+        });
+        return {
+            content,
+            reasoning,
+        };
+    }
+    /**
+     * Although this returns an array, only the first (or maybe last)
+     * element in the array is used. So we need to combine them into
+     * just one element that contains everything we need.
+     * @param response
+     */
     function responseToChatGenerations(response) {
-        let ret = responseToGroundedChatGenerations(response);
-        if (ret.length === 0) {
+        const generations = responseToGroundedChatGenerations(response);
+        if (generations.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("");
-            const toolCallChunks = ret[ret.length - 1]?.message.additional_kwargs?.tool_calls?.map((toolCall, i) => ({
-                name: toolCall.function.name,
-                args: toolCall.function.arguments,
-                id: toolCall.id,
-                index: i,
-                type: "tool_call_chunk",
-            }));
-            let usageMetadata;
-            if ("usageMetadata" in response.data) {
-                usageMetadata = {
-                    input_tokens: response.data.usageMetadata.promptTokenCount,
-                    output_tokens: response.data.usageMetadata
-                        .candidatesTokenCount,
-                    total_tokens: response.data.usageMetadata.totalTokenCount,
-                };
-            }
-            ret = [
-                new outputs_1.ChatGenerationChunk({
-                    message: new messages_1.AIMessageChunk({
-                        content: combinedContent,
-                        additional_kwargs: ret[ret.length - 1]?.message.additional_kwargs,
-                        tool_call_chunks: toolCallChunks,
-                        usage_metadata: usageMetadata,
-                    }),
-                    text: combinedText,
-                    generationInfo: ret[ret.length - 1].generationInfo,
-                }),
-            ];
-        }
+        const ret = combineGenerations(generations, response);
         // Add logprobs information to the message
         const candidate = response?.data
             ?.candidates?.[0];
@@ -847,6 +942,13 @@ function getGeminiAPI(config) {
                 ret.logprobs = parameters.topLogprobs;
             }
         }
+        // Remove any undefined properties, so we don't send them
+        let attribute;
+        for (attribute in ret) {
+            if (ret[attribute] === undefined) {
+                delete ret[attribute];
+            }
+        }
         return ret;
     }
     function formatSafetySettings(parameters) {

package/dist/utils/gemini.js

@@ -2,6 +2,7 @@ import { v4 as uuidv4 } from "uuid";
 import { AIMessage, AIMessageChunk, isAIMessage, } from "@langchain/core/messages";
 import { ChatGenerationChunk, } from "@langchain/core/outputs";
 import { isLangChainTool } from "@langchain/core/utils/function_calling";
+import { concat } from "@langchain/core/utils/stream";
 import { GoogleAISafetyError } from "./safety.js";
 import { GeminiSearchToolAttributes, } from "../types.js";
 import { zodToGeminiParameters } from "./zod_to_gemini_parameters.js";
@@ -599,9 +600,12 @@ export function getGeminiAPI(config) {
     function partToChatGeneration(part) {
         const message = partToMessageChunk(part);
         const text = partToText(part);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const generationInfo = {};
         return new ChatGenerationChunk({
             text,
             message,
+            generationInfo,
         });
     }
     function groundingSupportByPart(groundingSupports) {
@@ -652,43 +656,134 @@ export function getGeminiAPI(config) {
         });
         return ret;
     }
+    function combineContent(gen, forceComplex = false) {
+        const allString = gen.every((item) => typeof item.message.content === "string");
+        if (allString && !forceComplex) {
+            // Everything is a string, and we don't want to force it to return
+            // MessageContentComplex[], so concatenate the content into one string
+            return gen.map((item) => item.message.content).join("");
+        }
+        else {
+            // We either have complex types, or we want to force them, so turn
+            // it into an array of complex types.
+            const ret = [];
+            gen.forEach((item) => {
+                if (typeof item.message.content === "string") {
+                    // If this is a string, turn it into a text type
+                    ret.push({
+                        text: item.message.content,
+                    });
+                }
+                else {
+                    // Otherwise, add all the complex types to what we're returning
+                    item.message.content.forEach((c) => {
+                        ret.push(c);
+                    });
+                }
+            });
+            return ret;
+        }
+    }
+    function combineText(gen) {
+        return gen.map((item) => item.text ?? "").join("");
+    }
+    /*
+     * We don't really need the entire AIMessageChunk here, but it is
+     * a conventient way to combine all the Tool Calling information.
+     */
+    function combineToolCalls(gen) {
+        let ret = new AIMessageChunk("");
+        gen.forEach((item) => {
+            const message = item?.message;
+            ret = concat(ret, message);
+        });
+        return ret;
+    }
+    function combineAdditionalKwargs(gen) {
+        const ret = {};
+        gen.forEach((item) => {
+            const message = item?.message;
+            const kwargs = message?.additional_kwargs ?? {};
+            const keys = Object.keys(kwargs);
+            keys.forEach((key) => {
+                const value = kwargs[key];
+                if (Object.hasOwn(ret, key) &&
+                    Array.isArray(ret[key]) &&
+                    Array.isArray(value)) {
+                    ret[key].push(...value);
+                }
+                else {
+                    ret[key] = value;
+                }
+            });
+        });
+        return ret;
+    }
+    function combineGenerations(generations, response) {
+        const gen = splitGenerationTypes(generations, response);
+        const combinedContent = combineContent(gen.content);
+        const combinedText = combineText(gen.content);
+        const combinedToolCalls = combineToolCalls(gen.content);
+        const kwargs = combineAdditionalKwargs(gen.content);
+        const lastContent = gen.content[gen.content.length - 1];
+        // Add usage metadata
+        let usageMetadata;
+        if ("usageMetadata" in response.data) {
+            usageMetadata = {
+                input_tokens: response.data.usageMetadata.promptTokenCount,
+                output_tokens: response.data.usageMetadata
+                    .candidatesTokenCount,
+                total_tokens: response.data.usageMetadata.totalTokenCount,
+            };
+        }
+        // Add thinking / reasoning
+        // if (gen.reasoning && gen.reasoning.length > 0) {
+        //   kwargs.reasoning_content = combineContent(gen.reasoning, true);
+        // }
+        // Build the message and the generation chunk to return
+        const message = new AIMessageChunk({
+            content: combinedContent,
+            additional_kwargs: kwargs,
+            usage_metadata: usageMetadata,
+            tool_calls: combinedToolCalls.tool_calls,
+            invalid_tool_calls: combinedToolCalls.invalid_tool_calls,
+        });
+        return [
+            new ChatGenerationChunk({
+                message,
+                text: combinedText,
+                generationInfo: lastContent.generationInfo,
+            }),
+        ];
+    }
+    function splitGenerationTypes(generations, _response) {
+        const content = [];
+        const reasoning = [];
+        generations.forEach((gen) => {
+            if (gen?.generationInfo?.thought) {
+                reasoning.push(gen);
+            }
+            else {
+                content.push(gen);
+            }
+        });
+        return {
+            content,
+            reasoning,
+        };
+    }
+    /**
+     * Although this returns an array, only the first (or maybe last)
+     * element in the array is used. So we need to combine them into
+     * just one element that contains everything we need.
+     * @param response
+     */
     function responseToChatGenerations(response) {
-        let ret = responseToGroundedChatGenerations(response);
-        if (ret.length === 0) {
+        const generations = responseToGroundedChatGenerations(response);
+        if (generations.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("");
-            const toolCallChunks = ret[ret.length - 1]?.message.additional_kwargs?.tool_calls?.map((toolCall, i) => ({
-                name: toolCall.function.name,
-                args: toolCall.function.arguments,
-                id: toolCall.id,
-                index: i,
-                type: "tool_call_chunk",
-            }));
-            let usageMetadata;
-            if ("usageMetadata" in response.data) {
-                usageMetadata = {
-                    input_tokens: response.data.usageMetadata.promptTokenCount,
-                    output_tokens: response.data.usageMetadata
-                        .candidatesTokenCount,
-                    total_tokens: response.data.usageMetadata.totalTokenCount,
-                };
-            }
-            ret = [
-                new ChatGenerationChunk({
-                    message: new AIMessageChunk({
-                        content: combinedContent,
-                        additional_kwargs: ret[ret.length - 1]?.message.additional_kwargs,
-                        tool_call_chunks: toolCallChunks,
-                        usage_metadata: usageMetadata,
-                    }),
-                    text: combinedText,
-                    generationInfo: ret[ret.length - 1].generationInfo,
-                }),
-            ];
-        }
+        const ret = combineGenerations(generations, response);
         // Add logprobs information to the message
         const candidate = response?.data
             ?.candidates?.[0];
@@ -842,6 +937,13 @@ export function getGeminiAPI(config) {
                 ret.logprobs = parameters.topLogprobs;
             }
         }
+        // Remove any undefined properties, so we don't send them
+        let attribute;
+        for (attribute in ret) {
+            if (ret[attribute] === undefined) {
+                delete ret[attribute];
+            }
+        }
         return ret;
     }
     function formatSafetySettings(parameters) {

package/package.json

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