@langchain/google-common 0.1.8 → 0.2.1

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/types-anthropic.d.ts

@@ -17,6 +17,15 @@ export interface AnthropicMessageContentImage extends AnthropicMessageContentBas
         data: string;
     };
 }
+export interface AnthropicMessageContentThinking extends AnthropicMessageContentBase {
+    type: "thinking";
+    thinking: string;
+    signature: string;
+}
+export interface AnthropicMessageContentRedactedThinking extends AnthropicMessageContentBase {
+    type: "redacted_thinking";
+    data: string;
+}
 export type AnthropicMessageContentToolUseInput = object;
 export interface AnthropicMessageContentToolUse extends AnthropicMessageContentBase {
     type: "tool_use";
@@ -31,7 +40,7 @@ export interface AnthropicMessageContentToolResult extends AnthropicMessageConte
     is_error?: boolean;
     content: string | AnthropicMessageContentToolResultContent[];
 }
-export type AnthropicMessageContent = AnthropicMessageContentText | AnthropicMessageContentImage | AnthropicMessageContentToolUse | AnthropicMessageContentToolResult;
+export type AnthropicMessageContent = AnthropicMessageContentText | AnthropicMessageContentImage | AnthropicMessageContentToolUse | AnthropicMessageContentToolResult | AnthropicMessageContentThinking | AnthropicMessageContentRedactedThinking;
 export interface AnthropicMessage {
     role: string;
     content: string | AnthropicMessageContent[];
@@ -61,6 +70,14 @@ export interface AnthropicTool {
     cache_control?: AnthropicCacheControl;
     input_schema: AnthropicToolInputSchema;
 }
+export interface AnthropicThinkingEnabled {
+    type: "enabled";
+    budget_tokens: number;
+}
+export interface AnthropicThinkingDisabled {
+    type: "disabled";
+}
+export type AnthropicThinking = AnthropicThinkingEnabled | AnthropicThinkingDisabled;
 export interface AnthropicRequest {
     anthropic_version: string;
     messages: AnthropicMessage[];
@@ -74,6 +91,7 @@ export interface AnthropicRequest {
     metadata?: AnthropicMetadata;
     tool_choice?: AnthropicToolChoice;
     tools?: AnthropicTool[];
+    thinking?: AnthropicThinking;
 }
 export type AnthropicRequestSettings = Pick<AnthropicRequest, "max_tokens" | "temperature" | "top_k" | "top_p" | "stop_sequences" | "stream">;
 export interface AnthropicContentText {
@@ -86,7 +104,16 @@ export interface AnthropicContentToolUse {
     name: string;
     input: object;
 }
-export type AnthropicContent = AnthropicContentText | AnthropicContentToolUse;
+export interface AnthropicContentThinking {
+    type: "thinking";
+    thinking: string;
+    signature: string;
+}
+export interface AnthropicContentRedactedThinking {
+    type: "redacted_thinking";
+    data: string;
+}
+export type AnthropicContent = AnthropicContentText | AnthropicContentToolUse | AnthropicContentThinking | AnthropicContentRedactedThinking;
 export interface AnthropicUsage {
     input_tokens: number;
     output_tokens: number;
@@ -106,6 +133,7 @@ export interface AnthropicResponseMessage {
 }
 export interface AnthropicAPIConfig {
     version?: string;
+    thinking?: AnthropicThinking;
 }
 export type AnthropicStreamEventType = "message_start" | "content_block_start" | "content_block_delta" | "content_block_stop" | "message_delta" | "message_stop" | "ping" | "error";
 export type AnthropicStreamDeltaType = "text_delta" | "input_json_delta";

package/dist/utils/anthropic.cjs

@@ -70,6 +70,18 @@ function getAnthropicAPI(config) {
             tool_calls: [tool],
         };
     }
+    function thinkingContentToMessageFields(thinkingContent) {
+        // TODO: Once a reasoning/thinking type is defined in LangChain, use it
+        return {
+            content: [thinkingContent],
+        };
+    }
+    function redactedThinkingContentToMessageFields(thinkingContent) {
+        // TODO: Once a reasoning/thinking type is defined in LangChain, use it
+        return {
+            content: [thinkingContent],
+        };
+    }
     function anthropicContentToMessageFields(anthropicContent) {
         const type = anthropicContent?.type;
         switch (type) {
@@ -77,7 +89,12 @@ function getAnthropicAPI(config) {
                 return textContentToMessageFields(anthropicContent);
             case "tool_use":
                 return toolUseContentToMessageFields(anthropicContent);
+            case "thinking":
+                return thinkingContentToMessageFields(anthropicContent);
+            case "redacted_thinking":
+                return redactedThinkingContentToMessageFields(anthropicContent);
             default:
+                console.error(`Unknown message type: ${type}`, anthropicContent);
                 return undefined;
         }
     }
@@ -321,6 +338,25 @@ function getAnthropicAPI(config) {
             },
         };
     }
+    function thinkingContentToAnthropicContent(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    content) {
+        // TODO: Once a Langchain Thinking type is defined, use it
+        return {
+            type: "thinking",
+            thinking: content.thinking,
+            signature: content.signature,
+        };
+    }
+    function redactedThinkingContentToAnthropicContent(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    content) {
+        // TODO: Once a Langchain Thinking type is defined, use it
+        return {
+            type: "redacted_thinking",
+            data: content.data,
+        };
+    }
     function contentComplexToAnthropicContent(content) {
         const type = content?.type;
         switch (type) {
@@ -328,8 +364,12 @@ function getAnthropicAPI(config) {
                 return textContentToAnthropicContent(content);
             case "image_url":
                 return imageContentToAnthropicContent(content);
+            case "thinking":
+                return thinkingContentToAnthropicContent(content);
+            case "redacted_thinking":
+                return redactedThinkingContentToAnthropicContent(content);
             default:
-                console.warn(`Unexpected content type: ${type}`);
+                console.warn(`Unexpected content type: ${type}`, content);
                 return undefined;
         }
     }
@@ -344,6 +384,20 @@ function getAnthropicAPI(config) {
         });
         return ret;
     }
+    function toolCallToAnthropicContent(toolCall) {
+        return {
+            type: "tool_use",
+            id: toolCall.id,
+            name: toolCall.name,
+            input: toolCall.args,
+        };
+    }
+    function toolCallsToAnthropicContent(toolCalls) {
+        if (toolCalls === undefined) {
+            return [];
+        }
+        return toolCalls.map(toolCallToAnthropicContent);
+    }
     function baseRoleToAnthropicMessage(base, role) {
         const content = contentToAnthropicContent(base.content);
         return {
@@ -351,6 +405,15 @@ function getAnthropicAPI(config) {
             content,
         };
     }
+    function aiMessageToAnthropicMessage(base) {
+        const ret = baseRoleToAnthropicMessage(base, "assistant");
+        const toolContent = toolCallsToAnthropicContent(base.tool_calls);
+        if (toolContent.length > 0) {
+            const content = ret.content;
+            ret.content = [...content, ...toolContent];
+        }
+        return ret;
+    }
     function toolMessageToAnthropicMessage(base) {
         const role = "user";
         const toolUseId = base.tool_call_id;
@@ -373,10 +436,11 @@ function getAnthropicAPI(config) {
             case "human":
                 return baseRoleToAnthropicMessage(base, "user");
             case "ai":
-                return baseRoleToAnthropicMessage(base, "assistant");
+                return aiMessageToAnthropicMessage(base);
             case "tool":
                 return toolMessageToAnthropicMessage(base);
             default:
+                console.warn(`Unknown BaseMessage type: ${type}`, base);
                 return undefined;
         }
     }
@@ -519,6 +583,9 @@ function getAnthropicAPI(config) {
         if (system?.length) {
             ret.system = system;
         }
+        if (config?.thinking) {
+            ret.thinking = config?.thinking;
+        }
         return ret;
     }
     return {

package/dist/utils/anthropic.js

@@ -67,6 +67,18 @@ export function getAnthropicAPI(config) {
             tool_calls: [tool],
         };
     }
+    function thinkingContentToMessageFields(thinkingContent) {
+        // TODO: Once a reasoning/thinking type is defined in LangChain, use it
+        return {
+            content: [thinkingContent],
+        };
+    }
+    function redactedThinkingContentToMessageFields(thinkingContent) {
+        // TODO: Once a reasoning/thinking type is defined in LangChain, use it
+        return {
+            content: [thinkingContent],
+        };
+    }
     function anthropicContentToMessageFields(anthropicContent) {
         const type = anthropicContent?.type;
         switch (type) {
@@ -74,7 +86,12 @@ export function getAnthropicAPI(config) {
                 return textContentToMessageFields(anthropicContent);
             case "tool_use":
                 return toolUseContentToMessageFields(anthropicContent);
+            case "thinking":
+                return thinkingContentToMessageFields(anthropicContent);
+            case "redacted_thinking":
+                return redactedThinkingContentToMessageFields(anthropicContent);
             default:
+                console.error(`Unknown message type: ${type}`, anthropicContent);
                 return undefined;
         }
     }
@@ -318,6 +335,25 @@ export function getAnthropicAPI(config) {
             },
         };
     }
+    function thinkingContentToAnthropicContent(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    content) {
+        // TODO: Once a Langchain Thinking type is defined, use it
+        return {
+            type: "thinking",
+            thinking: content.thinking,
+            signature: content.signature,
+        };
+    }
+    function redactedThinkingContentToAnthropicContent(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    content) {
+        // TODO: Once a Langchain Thinking type is defined, use it
+        return {
+            type: "redacted_thinking",
+            data: content.data,
+        };
+    }
     function contentComplexToAnthropicContent(content) {
         const type = content?.type;
         switch (type) {
@@ -325,8 +361,12 @@ export function getAnthropicAPI(config) {
                 return textContentToAnthropicContent(content);
             case "image_url":
                 return imageContentToAnthropicContent(content);
+            case "thinking":
+                return thinkingContentToAnthropicContent(content);
+            case "redacted_thinking":
+                return redactedThinkingContentToAnthropicContent(content);
             default:
-                console.warn(`Unexpected content type: ${type}`);
+                console.warn(`Unexpected content type: ${type}`, content);
                 return undefined;
         }
     }
@@ -341,6 +381,20 @@ export function getAnthropicAPI(config) {
         });
         return ret;
     }
+    function toolCallToAnthropicContent(toolCall) {
+        return {
+            type: "tool_use",
+            id: toolCall.id,
+            name: toolCall.name,
+            input: toolCall.args,
+        };
+    }
+    function toolCallsToAnthropicContent(toolCalls) {
+        if (toolCalls === undefined) {
+            return [];
+        }
+        return toolCalls.map(toolCallToAnthropicContent);
+    }
     function baseRoleToAnthropicMessage(base, role) {
         const content = contentToAnthropicContent(base.content);
         return {
@@ -348,6 +402,15 @@ export function getAnthropicAPI(config) {
             content,
         };
     }
+    function aiMessageToAnthropicMessage(base) {
+        const ret = baseRoleToAnthropicMessage(base, "assistant");
+        const toolContent = toolCallsToAnthropicContent(base.tool_calls);
+        if (toolContent.length > 0) {
+            const content = ret.content;
+            ret.content = [...content, ...toolContent];
+        }
+        return ret;
+    }
     function toolMessageToAnthropicMessage(base) {
         const role = "user";
         const toolUseId = base.tool_call_id;
@@ -370,10 +433,11 @@ export function getAnthropicAPI(config) {
             case "human":
                 return baseRoleToAnthropicMessage(base, "user");
             case "ai":
-                return baseRoleToAnthropicMessage(base, "assistant");
+                return aiMessageToAnthropicMessage(base);
             case "tool":
                 return toolMessageToAnthropicMessage(base);
             default:
+                console.warn(`Unknown BaseMessage type: ${type}`, base);
                 return undefined;
         }
     }
@@ -516,6 +580,9 @@ export function getAnthropicAPI(config) {
         if (system?.length) {
             ret.system = system;
         }
+        if (config?.thinking) {
+            ret.thinking = config?.thinking;
+        }
         return ret;
     }
     return {

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.1",
   "description": "Core types and classes for Google services.",
   "type": "module",
   "engines": {